microsoft/semantic-kernel

This system is the Microsoft Agent Framework, formerly known as Semantic Kernel, which serves as a .NET SDK for integrating Large Language Models into applications. It provides a unified orchestration layer that supports multimodal interactions, memory management via vector stores, and complex agent workflows. The framework enables developers to connect with various AI providers, including cloud services and local models, while facilitating features like retrieval-augmented generation and function calling.

116 changes.

The .NET SDK underwent a comprehensive overhaul to align with the Microsoft Agent Framework 1.0, replacing legacy Semantic Kernel APIs with modern abstractions and a new kernel construction model. This period focused on removing obsolete components like the old orchestration and memory systems while introducing bidirectional integration with Microsoft.Extensions.AI and enhancing security across plugins and connectors.

198 changes.

This period focused on introducing the Semantic Kernel Agent Framework, including core abstractions, multi-agent orchestration, and specialized implementations for OpenAI and Azure AI. It also significantly expanded connector support by adding new integrations for Hugging Face, Mistral AI, and Amazon Bedrock, while modernizing existing connectors like OpenAI and Google Gemini to align with Microsoft.Extensions.AI abstractions.

91 changes.

This period focused on significantly expanding the agent ecosystem by introducing native support for Azure AI, AWS Bedrock, and Microsoft Copilot Studio, alongside a new declarative YAML definition system. It also established a robust multi-agent orchestration framework with patterns like concurrent execution and group chats, while integrating the Model Context Protocol (MCP) and Microsoft.Extensions.AI standards for broader interoperability.

A new sample file (Step01\_A2AAgent.cs) has been added to the GettingStartedWithAgents/A2A directory, providing a concrete example of how to use the A2A agent implementation. The sample demonstrates creating an A2AClient and A2ACardResolver to connect to an agent URL, retrieving the agent card, and invoking the agent both synchronously and via streaming to retrieve chat message content.

dotnet/samples/GettingStartedWithAgents/A2A · high confidence

Developers can now integrate Amazon Bedrock models into Semantic Kernel via new extension methods on \IKernelBuilder\ and \IServiceCollection\. This location provides the dependency-injection wiring for \IChatCompletionService\, \IChatClient\, \ITextGenerationService\, and \IEmbeddingGenerator\, allowing users to register Bedrock services with optional OpenTelemetry and logging configuration. The entry also marks the legacy \AddBedrockTextEmbeddingGenerationService\ and \BedrockTextEmbeddingGenerationService\ as obsolete in favor of the new \IEmbeddingGenerator\-based approach.

dotnet/src/Connectors/Connectors.Amazon/Bedrock/Extensions · high confidence

A new interactive demo application has been added to the samples directory, allowing users to experiment with Amazon Bedrock models via the AWS SDK for .NET. The program supports four modes: chat completion, text generation, streaming chat completion, and streaming text generation. Users can select from available foundation models based on their supported modalities, and the demo displays usage metadata and inner content from the Bedrock responses.

dotnet/samples/Demos/AmazonBedrockModels · high confidence

A new console-based demo application is introduced to showcase Copilot Agent Plugins (CAPs) within Semantic Kernel. The sample allows users to load and interact with plugins for Microsoft Graph operations (such as Calendar, Contacts, Messages, and DriveItems) using Azure OpenAI, OpenAI, or local Ollama models. It includes a custom CLI interface for managing plugin lifecycles, a bearer authentication provider for Microsoft 365 delegated access via Device Code flow, and enhanced logging to visualize function calls and results.

dotnet/samples/Demos/CopilotAgentPlugins · high confidence

Users can now invoke prompts using the Handlebars template format via the new \InvokeHandlebarsPromptAsync\ extension method on the \Kernel\ class. This addition allows for more flexible and powerful prompt templating capabilities within the Semantic Kernel.

dotnet/src/Extensions/PromptTemplates.Handlebars/Extensions · high confidence

Introduces the Mem0Provider, Mem0Client, and Mem0ProviderOptions classes to enable Semantic Kernel to integrate with the Mem0 memory service. This allows applications to automatically capture conversation messages as memories and retrieve relevant context during AI invocations, with support for scoping memories by application, agent, thread, and user.

dotnet/src/SemanticKernel.Core/Memory/Mem0 · high confidence

A new console application sample has been added to demonstrate Retrieval Augmented Generation (RAG) using local ONNX models. The demo integrates the Phi-3 chat model and BGE-Micro-V2 embedding model via the Semantic Kernel ONNX connectors, utilizing the InMemoryVectorStore to index fact files and enable semantic search within a streaming chat interface.

dotnet/samples/Demos/OnnxSimpleRAG · high confidence

Added a new console application sample in the OpenAIRealtime demo that demonstrates using the OpenAI Realtime API for conversational experiences with function calling. The sample shows how to configure credentials for both OpenAI and Azure OpenAI, establish a real-time conversation session, and integrate Semantic Kernel plugins to handle tool calls during the interaction.

dotnet/samples/Demos/OpenAIRealtime · high confidence

Introduces a new sample demonstrating how to integrate the Semantic Kernel Process Framework with .NET Aspire. The demo features an AppHost that orchestrates three services: a ProcessOrchestrator, a TranslatorAgent, and a SummaryAgent. The orchestrator defines a business process where a document is first translated and then summarized, with each step invoking an external agent via HTTP. The agents are implemented as standalone services using Azure OpenAI (gpt-4o) and are configured with .NET Aspire service discovery, OpenTelemetry tracing, and health checks to enable observability and independent management via the Aspire dashboard.

dotnet/samples/Demos/ProcessFrameworkWithAspire · high confidence

Developers can now create KernelFunctions directly from Prompty template files or strings using new extension methods on the Kernel class. The \CreateFunctionFromPromptyFile\ methods allow loading templates from the file system, supporting both standard file paths and custom IFileProvider instances for flexible file resolution. The \CreateFunctionFromPrompty\ method enables creating functions from template strings, with optional support for custom prompt template factories to handle Liquid and Handlebars syntax.

dotnet/src/Functions/Functions.Prompty/Extensions · high confidence

Added configuration files for the Python project, including \.coveragerc\ for code coverage, \.cspell.json\ for spell checking, \.editorconfig\ for consistent coding styles, \.env.example\ for environment variable templates, \.pre-commit-config.yaml\ for pre-commit hooks, and VS Code settings for debugging and formatting. Also added a \Makefile\ for managing installation and testing, \mypy.ini\ for type checking, and initial sample documentation.

python · high confidence

A new .NET console sample demonstrates a voice chat pipeline that captures microphone audio, processes it through Voice Activity Detection (VAD), Speech-to-Text (STT), Semantic Kernel chat completion, and Text-to-Speech (TTS), then plays the response back. The demo uses .NET Dataflow to chain these stages, supports user interruption to start a new turn, and relies on OpenAI APIs for transcription, chat, and speech synthesis.

dotnet/samples/Demos/VoiceChat · high confidence

Users can now use Semantic Kernel agents within the Microsoft Agent Framework ecosystem. This change introduces the \SemanticKernelAIAgent\ and \SemanticKernelAIAgentSession\ classes, which act as adapters to expose a Semantic Kernel \Agent\ as a Microsoft Agent Framework \AIAgent\. This allows developers to leverage existing Semantic Kernel agent logic while utilizing the standardized interfaces and session management provided by the Microsoft Agent Framework.

dotnet/src/Agents/Abstractions/AIAgent · high confidence

Users can now define prompt functions and plugins using YAML configuration files. This change introduces the \KernelFunctionYaml\ class with a \FromPromptYaml\ method to create individual functions from YAML text, and \PromptYamlKernelExtensions\ to provide \CreateFunctionFromPromptYaml\, \CreatePluginFromPromptDirectoryYaml\, and \ImportPluginFromPromptDirectoryYaml\ extension methods. These extensions allow loading plugins from directories containing \.yaml\ or \.yml\ files, automatically mapping file names to function names. The implementation includes a custom \PromptExecutionSettingsTypeConverter\ to handle polymorphic deserialization of \FunctionChoiceBehavior\ settings from YAML, ensuring that prompt execution settings are correctly parsed. Note that the directory-based plugin creation methods currently require reflection and dynamic code, making them incompatible with Native-AOT scenarios.

dotnet/src/Functions/Functions.Yaml · high confidence

Users can now define prompt functions using Markdown syntax via the new Functions.Markdown package. This introduces the \KernelFunctionMarkdown\ class and \MarkdownKernelExtensions.CreateFunctionFromMarkdown\ extension method, which parse Markdown text containing fenced code blocks (specifically \sk.prompt\ for the template and \sk.execution\_settings\ for configuration) to generate \KernelFunction\ instances. The assembly is marked as experimental with ID SKEXP0040.

dotnet/src/Functions/Functions.Markdown · high confidence

The Vertex AI connector now allows users to specify the number of dimensions for generated embeddings. This is achieved by introducing a new \VertexAIEmbeddingClient\ that accepts an optional \dimensions\ parameter, which is passed through to the Vertex AI API request via the \outputDimensionality\ field. If not specified, the model's default dimensionality is used.

dotnet/src/Connectors/Connectors.Google/Core/VertexAI · high confidence

The samples now include the necessary resource files (dict.txt, encoder.json, vocab.bpe) for the EnglishRoberta model in the Resources/EnglishRoberta directory, and introduce two new sample plugins: EmailPlugin, which demonstrates sending emails and looking up addresses, and StaticTextPlugin, which provides text transformation functions like uppercase conversion.

dotnet/samples/Concepts/Resources/EnglishRoberta, dotnet/samples/Concepts/Resources/Plugins · high confidence

The LearnResources sample directory now includes three new Grimm's Fairy Tales text files ("The King of the Golden Mountain", "The Water of Life", and "The White Snake") and two CSV datasets containing population statistics by country and administrative region. These resources are available for use in .NET samples to demonstrate data handling and text processing capabilities.

dotnet/samples/LearnResources/Resources · high confidence

This change introduces two new internal components to support the Gemini connector: an AuthorRoleConverter that maps between Semantic Kernel's AuthorRole enum and the Gemini API's string-based roles (user, model, function), and a GeminiPluginCollectionExtensions helper that resolves KernelFunction instances from a plugin collection based on Gemini function tool calls. These additions enable proper serialization of chat roles and facilitate the execution of tool calls within the Gemini integration.

dotnet/src/Connectors/Connectors.Google/Core/Gemini · high confidence

The demo server now includes a new PromptDefinition class that bridges Semantic Kernel prompt templates with the Model Context Protocol. This component allows the server to expose Semantic Kernel prompts (defined via Handlebars templates) as MCP prompts, automatically handling argument mapping and prompt rendering using the kernel instance.

dotnet/samples/Demos/ModelContextProtocolClientServer/MCPServer/Prompts · high confidence

The AotCompatibility demo now includes samples demonstrating how to use Semantic Kernel in Native-AOT applications. This includes creating and invoking kernel functions from lambdas, creating and importing kernel plugins, and using the ONNX chat completion service. The samples also provide guidance on configuring JSON serializer contexts to ensure type information is preserved for AOT compatibility.

dotnet/samples/Demos/AotCompatibility · high confidence

The \dotnet/src/InternalUtilities/src/Data\ location now includes \VectorStoreErrorHandler.cs\, which provides internal helper methods for executing vector store operations. This utility standardizes error handling by wrapping calls in try-catch blocks that convert specific exceptions into \VectorStoreException\ instances enriched with metadata (such as store name, system name, and collection name). It also introduces a \RunOperationWithRetryAsync\ method, allowing operations to automatically retry with a configurable delay and maximum attempt count before failing, thereby improving resilience for vector data interactions.

dotnet/src/InternalUtilities/src/Data · high confidence

Introduced a new extension method for KernelArguments that merges a primary set of arguments with an override set, ensuring that override values take precedence for both execution settings and parameters. This utility allows for incremental addition or replacement of specific parameters while preserving the ability to override execution settings, facilitating more flexible argument handling in agent-based workflows.

dotnet/src/InternalUtilities/arguments · high confidence

The mcp-simple-auth sample now includes two new demonstration servers: a dedicated Authorization Server (auth\_server.py) that handles OAuth flows, client registration, and token issuance with an introspection endpoint, and a legacy combined server (legacy\_as\_server.py) that acts as both Authorization and Resource Server for backwards compatibility testing. These samples illustrate how to implement MCP authentication using simple credential-based OAuth flows and can be replaced with enterprise identity providers.

mcp-simple-auth · high confidence

The MCPServer sample now includes a helper class, EmbeddedResource, which allows the application to read embedded files (such as JSON templates and text documentation) as strings, byte arrays, or streams. This utility supports the new 'Mcp sampling' demo by providing access to a weather function template (GetCurrentWeatherForCity.json) and Semantic Kernel informational text, enabling the server to load these resources dynamically during runtime.

dotnet/samples/Demos/ModelContextProtocolClientServer/MCPServer/ProjectResources · high confidence

A new \ProtoDocumentParser\ class has been added to the \Microsoft.SemanticKernel.Plugins.Grpc.Protobuf\ namespace. This component enables the system to parse .proto definition files and extract gRPC service operations, including request and response data contracts, which are necessary for integrating gRPC-based functions into the kernel.

dotnet/src/Functions/Functions.Grpc/Protobuf · high confidence

This change introduces internal helper classes and policies within the Azure utilities to support routing and processing for Azure AI Agents and Foundry Workflows. It adds a generic action pipeline policy for message processing, specific HTTP pipeline policies (\HttpPipelineRoutingPolicy\, \PipelineRoutingPolicy\) that handle endpoint routing and API versioning, and URI extension methods that automatically reroute requests to the correct workflow or agent endpoints (e.g., rewriting paths for \services.ai.azure.com\ or Machine Learning RP) and inject necessary query parameters like file search citation results.

dotnet/src/InternalUtilities/azure · high confidence

This change introduces internal helper extensions in the \meai\ utility folder that bridge the gap between the \Microsoft.Extensions.AI\ abstraction and Semantic Kernel's native types. Specifically, \ChatMessageExtensions\ provides methods to convert \ChatMessage\ objects into Semantic Kernel's \ChatMessageContent\ and \ChatHistory\, handling the mapping of text, images, audio, binary data, and function calls. This enables Semantic Kernel agents to consume and process chat interactions standardized through the \Microsoft.Extensions.AI\ interface.

dotnet/src/InternalUtilities/meai · high confidence

Users now have access to detailed, optimized logging for the OpenAI Assistant agent lifecycle. New static logging methods track key events such as creating and restoring assistant channels (threads), initiating and completing runs, processing run steps and messages, and polling run status. This enables better observability into the internal state and progress of assistant interactions.

dotnet/src/Agents/OpenAI/Logging · high confidence

A new RepoFiles utility class has been added to the TelemetryWithAppInsights demo to help locate the 'prompt\_template\_samples' folder within the repository structure. This utility scans parent directories to find the required plugins, ensuring the application can access necessary sample data at runtime.

dotnet/samples/Demos/TelemetryWithAppInsights/RepoUtils · high confidence

Introduced the \Workflow\ and \WorkflowWrapper\ classes in the Process.Abstractions serialization layer to enable serializing and deserializing workflow definitions. This new model supports both YAML and JSON formats, allowing users to define workflows with specific IDs, format versions, nodes, orchestration steps, variables, and error handling configurations that can be persisted or transmitted in standard data interchange formats.

dotnet/src/Experimental/Process.Abstractions/Serialization · high confidence

This change introduces internal utility components for the Agents framework. It adds a build configuration file (AgentUtilities.props) to include agent source files in the compilation. It also adds extension methods for the Agent class to safely retrieve the agent's name, display name, and associated kernel, ensuring consistent naming for telemetry and invocation. Additionally, it provides an extension method for KernelFunctionMetadata to transform function parameter metadata into a binary JSON schema specification, which is used for defining function parameters.

dotnet/src/InternalUtilities/agents · high confidence

The Azure AI Inference connector now exposes a dedicated \AzureAIInferencePromptExecutionSettings\ class, allowing users to fine-tune chat completion behavior. This includes controls for creativity and focus (temperature, top\_p, frequency\_penalty, presence\_penalty), output constraints (max\_tokens, stop sequences, response format), and tool usage (tools). A seed parameter is also available to attempt deterministic sampling for reproducible results.

dotnet/src/Connectors/Connectors.AzureAIInference/Settings · high confidence

The Azure AI Inference connector has been updated to integrate with Microsoft.Extensions.AI abstractions, allowing users to register chat completion and embedding services via standard DI extensions. This change introduces built-in OpenTelemetry support for tracing and metrics, configurable via optional source names and callbacks, and provides new extension methods on IKernelBuilder and IServiceCollection to wire up the connector with API keys, token credentials, or pre-configured clients.

dotnet/src/Connectors/Connectors.AzureAIInference/Extensions · high confidence

The Azure OpenAI connector now supports additional Azure OpenAI API versions (including 2024-06-01, 2024-08-01-preview, 2024-09-01-preview, 2024-10-01-preview, 2024-12-01-preview, 2025-01-01-preview, 2025-03-01-preview, and 2025-04-01-preview) via an optional version parameter in the client constructors. It also introduces new execution settings: UserSecurityContext for security context propagation, SetNewMaxCompletionTokensEnabled to enforce the new max\_completion\_tokens parameter, AzureChatDataSource for Azure Search integration, and support for response modalities and audio options in chat completions. The connector also supports parallel tool calls, token selection biases, and metadata in prompt execution settings.

dotnet/src/Connectors/Connectors.AzureOpenAI/Core · high confidence

This change introduces a set of adapter classes and extension methods in the ChatCompletion abstractions that enable seamless interoperability between Semantic Kernel and the Microsoft.Extensions.AI (MEAI) interfaces. Users can now wrap an existing IChatCompletionService as an IChatClient via the new AsChatClient() extension, or convert an MEAI AIFunction into a KernelFunction using AsKernelFunction(). The implementation includes ChatClientChatCompletionService and ChatCompletionServiceChatClient to handle the translation of chat histories, streaming responses, and function call content between the two ecosystems, along with supporting types like AuthorRole and ChatPromptParser to standardize message handling.

dotnet/src/SemanticKernel.Abstractions/AI/ChatCompletion · high confidence

Users can now define agents declaratively using YAML files. This change introduces the AgentDefinitionYaml helper and YamlAgentFactoryExtensions to parse YAML text into AgentDefinition models, supporting variable substitution via ${key} syntax resolved from IConfiguration. Custom type converters handle AgentMetadata and ModelConnection deserialization, and the Normalize method ensures input/output names match dictionary keys and configuration values are interpolated.

dotnet/src/Agents/Yaml · high confidence

The Google connector now exposes a comprehensive set of new settings in GeminiPromptExecutionSettings, including responseMimeType, responseSchema (for structured outputs), audioTimestamp, cachedContent, and labels for request metadata. It introduces GeminiThinkingConfig to control thinking budget and level for newer Gemini models, and allows users to include reasoning thoughts in responses. Tool calling is significantly enhanced with GeminiToolCallBehavior, supporting auto-invocation of kernel functions, specific function lists, and increased auto-invoke limits. Additionally, the connector now supports selecting between Google AI and Vertex AI API versions (V1 and V1-beta) via new enum types.

dotnet/src/Connectors/Connectors.Google · high confidence

Added the Magentic orchestration system, enabling a group-chat pattern where a manager agent coordinates a team of member agents to complete tasks. This includes the \MagenticOrchestration\ class for managing the lifecycle, a \MagenticManagerActor\ that enforces limits on invocations, stalls, and resets, and a \StandardMagenticManager\ that uses LLMs to evaluate progress via a structured \MagenticProgressLedger\. The implementation also introduces specific message types (\Speak\, \Group\, \Reset\), prompt templates for fact/plan analysis, and logging extensions for the orchestration flow.

dotnet/src/Agents/Magentic · high confidence

The Functions.Prompty package introduces experimental support (SKEXP0040) for creating Semantic Kernel functions from Prompty templates. Users can now use the new KernelFunctionPrompty class to parse Prompty content into PromptTemplateConfig objects or directly instantiate KernelFunctions, with built-in support for resolving relative file references securely and mapping model options like temperature and stop sequences to execution settings.

dotnet/src/Functions/Functions.Prompty · high confidence

The Google and Vertex AI connector extension methods in the kernel and service collection builders now allow users to configure the number of dimensions for embedding generation services (AddGoogleAIEmbeddingGenerator, AddVertexAIEmbeddingGenerator, etc.), enabling smaller, more efficient embeddings. Additionally, new extension methods (AddGoogleGenAIChatClient, AddGoogleAIChatClient, AddGoogleVertexAIChatClient) are available to register the official Google.GenAI IChatClient implementation, which includes OpenTelemetry support and kernel function invocation. The older embedding generation methods (AddGoogleAIEmbeddingGeneration, AddVertexAIEmbeddingGeneration) and memory builder methods (WithGoogleAITextEmbeddingGeneration, WithVertexAITextEmbeddingGeneration) are now marked obsolete in favor of the new embedding generator and vector store approaches. A new extension (GeminiKernelFunctionMetadataExtensions.ToGeminiFunction) is also provided to convert KernelFunctionMetadata to GeminiFunction.

dotnet/src/Connectors/Connectors.Google/Extensions · high confidence

The Google connector now includes a new ClientBase class that handles HTTP request creation, authentication, and response processing. This implementation supports both API key authentication (via the x-goog-api-key header) and bearer token authentication. It introduces explicit API version selection for both Google AI (v1, v1beta) and Vertex AI (v1, v1beta1) endpoints, with proper URI construction for Vertex AI global and regional locations. The client also validates max tokens and provides utilities for JSON deserialization and HTTP request handling.

dotnet/src/Connectors/Connectors.Google/Core · high confidence

The Hugging Face connector now includes its core client implementation (\HuggingFaceClient\) and a dedicated message API client (\HuggingFaceMessageApiClient\) for chat completions, supporting both streaming and non-streaming modes. This change introduces the underlying HTTP request handling, model diagnostics integration, and token usage logging for the connector. It also adds the necessary data models for text generation, chat completion, streaming responses, embeddings, and image-to-text tasks, enabling the connector to communicate with the Hugging Face Inference API.

dotnet/src/Connectors/Connectors.HuggingFace/Core · high confidence

This change introduces the foundational components for the new Azure AI Inference connector, enabling users to interact with Azure AI Inference services. It adds a core client class (\ChatClientCore\) that supports both API key and token-based authentication, allowing configuration of custom endpoints, model IDs, and HTTP clients. Additionally, it includes a pipeline policy (\AddHeaderRequestPolicy\) for injecting custom headers into requests and extension methods to convert Azure SDK exceptions into standard HTTP operation exceptions for consistent error handling.

dotnet/src/Connectors/Connectors.AzureAIInference/Core · high confidence

This change introduces the core abstractions for the .NET Agent Runtime, providing the foundational types and interfaces required to build agent-based applications. It adds \AgentId\, \AgentType\, and \TopicId\ structs for strongly-typed identification of agents and message topics, along with \AgentMetadata\ for agent details. The runtime interface \IAgentRuntime\ defines the contract for sending messages, publishing to topics, managing subscriptions, and handling agent state persistence. Additionally, \AgentProxy\ is provided as a convenient wrapper for interacting with agents, and specific exceptions like \CantHandleException\ and \UndeliverableException\ are introduced to handle runtime errors. Unit tests are included to validate the behavior of these new types.

dotnet/src/Agents/Runtime · high confidence

The Amazon Bedrock connector now supports text generation and chat completion for Amazon Titan, Anthropic Claude, and AI21 Labs (Jurassic and Jamba) models, as well as text embedding generation for Amazon Titan. This adds the underlying request/response models and service implementations required to interact with these providers through the connector.

dotnet/src/Connectors/Connectors.Amazon/Bedrock/Core/Models · high confidence

Added internal classes in the planning Schema utility to describe KernelFunctionFactory definitions in a JSON Schema-friendly format. These models (JsonSchemaFunctionView, JsonSchemaFunctionParameters, JsonSchemaFunctionResponse, etc.) structure function metadata such as name, description, parameters, and response schemas, enabling the planning system to serialize and process function capabilities for AI interactions.

dotnet/src/InternalUtilities/planning/Schema · high confidence

Adds a new A2A agent implementation that enables Semantic Kernel agents to communicate via the A2A protocol. This includes the A2AAgent class for invoking remote agents, A2AAgentThread for managing conversation state, and A2AHostAgent for exposing agents as A2A services. Additionally, A2AAgentExtensions provides an adapter to expose Semantic Kernel agents as Microsoft Agent Framework AIAgents, facilitating interoperability between the two frameworks.

dotnet/src/Agents/A2A · high confidence

Adds extension methods in the Bedrock agent location to bridge Semantic Kernel agents with the AWS Bedrock Agent service. This enables users to configure agents with code interpreters, knowledge bases, and kernel functions (tools) via declarative definitions, and provides runtime support for invoking agents with automatic function calling, streaming responses, and binary file handling.

dotnet/src/Agents/Bedrock/Extensions · high confidence

This change adds the core client implementations for the new Amazon Bedrock connector in Semantic Kernel. The \BedrockChatCompletionClient\ enables chat completion with support for streaming responses, token usage tracking, and OpenTelemetry diagnostics. The \BedrockTextGenerationClient\ provides both synchronous and asynchronous text generation capabilities, including streaming support. Additionally, the \BedrockTextEmbeddingGenerationClient\ introduces text embedding generation, supporting both single and batch processing modes. These clients handle the underlying AWS Bedrock runtime interactions, model invocation, and response conversion to Semantic Kernel's internal types.

dotnet/src/Connectors/Connectors.Amazon/Bedrock/Core/Clients · high confidence

This change adds the foundational core components for the new Amazon Bedrock connector, including utility classes for mapping HTTP status codes and conversation roles, a service factory that routes model IDs to specific provider implementations (such as Anthropic, Meta, and Cohere), and internal interfaces defining the request/response contracts for text generation, chat completion, and text embedding services.

dotnet/src/Connectors/Connectors.Amazon/Bedrock/Core · high confidence

The Agents/Core module now provides the core building blocks for the Semantic Kernel Agent Framework. This includes the ChatCompletionAgent, which wraps the IChatCompletionService to enable function calling and supports configurable instruction roles (e.g., 'system' vs 'developer') and history reduction strategies. It also introduces AgentGroupChat, a multi-turn chat coordinator that manages a collection of agents, allowing them to interact sequentially based on defined selection and termination strategies. Additionally, the module adds ChatHistoryAgentThread for managing conversation state and ChatHistoryChannel to handle message flow and history reduction within the agent lifecycle.

dotnet/src/Agents/Core · high confidence

Adds a new \BedrockAgent\ class and supporting components (\BedrockAgentChannel\, \BedrockAgentThread\, \BedrockAgentInvokeOptions\) to the .NET SDK, enabling users to invoke AWS Bedrock Agents within Semantic Kernel workflows. This integration handles session management via the Bedrock runtime, adapts chat history to meet Bedrock's alternating role requirements, and exposes agent capabilities such as tool use (action groups), code interpretation, and knowledge base retrieval.

dotnet/src/Agents/Bedrock · high confidence

New extension methods in the \dotnet/src/Agents/AzureAI/Extensions\ directory enable the Semantic Kernel to map internal agent definitions to Azure AI tool definitions and resources. \AgentDefinitionExtensions\ now translates tool types (such as Azure AI Search, File Search, Code Interpreter, and OpenAPI) into their corresponding Azure AI SDK models and resolves the necessary \PersistentAgentsClient\ or \AIProjectClient\ from the kernel's service collection. \AgentToolDefinitionExtensions\ handles the parsing of specific tool parameters, including Azure Function bindings, vector store configurations, and data sources. Additionally, \AgentRunExtensions\ provides helpers to construct run requests with invocation options like truncation strategies and JSON response formats, while \KernelFunctionExtensions\ allows standard kernel functions to be converted into OpenAI-compatible tool definitions for use within Azure AI agents.

dotnet/src/Agents/AzureAI/Extensions · high confidence

This change adds a new \AzureAIAgent\ implementation to the Semantic Kernel Agent Framework, enabling users to create and invoke agents backed by the Azure AI Foundry service. The update includes the \AzureAIAgent\ class and its supporting components—such as \AzureAIAgentThread\ for conversation management, \AzureAIAgentInvokeOptions\ for configuring invocation parameters (e.g., model selection, tool enablement, and temperature), and \AzureAIChannel\ for handling the underlying communication. It also provides a client factory for establishing connections to Azure AI and extension methods to expose the agent as a standard \AIAgent\. Users can now integrate Azure AI agents into their Semantic Kernel workflows with support for features like code interpretation and file search.

dotnet/src/Agents/AzureAI · high confidence

Adds a new \CopilotStudioAgent\ implementation that allows Semantic Kernel agents to interact with Microsoft Copilot Studio agents via programmatic APIs. This includes the agent class, a dedicated thread implementation (\CopilotStudioAgentThread\), and connection settings (\CopilotStudioConnectionSettings\) supporting both interactive and service-to-service authentication via Entra ID. The agent invokes Copilot Studio agents using the \CopilotClient\, processes incoming activities (messages, typing indicators, suggested actions) into standard kernel content, and provides an extension method (\AsAIAgent\) to expose the Semantic Kernel agent as a Microsoft Agent Framework \AIAgent\. Note that prompt templates are not supported, and streaming responses are currently not supported.

dotnet/src/Agents/Copilot · high confidence

This change adds a new Dapr runtime implementation for Semantic Kernel Processes, enabling process execution via Dapr Actors. It introduces a set of actors to manage process state and communication, including ProcessActor, StepActor, MapActor, and ProxyActor for core workflow logic, along with EventBufferActor, MessageBufferActor, and ExternalEventBufferActor for handling internal and external event queues. The implementation includes serialization helpers (DaprProcessInfo, DaprMapInfo, DaprProxyInfo, DaprStepInfo) to convert between kernel process models and Dapr-compatible state, and provides a public entry point via DaprKernelProcessFactory and DaprKernelProcessContext to start and manage processes. This runtime is marked as experimental (SKEXP0080).

dotnet/src/Experimental/Process.Runtime.Dapr · high confidence

Adds a new experimental Flow Orchestrator that executes multi-step AI workflows using a ReAct (Reasoning-Action-Observation) engine. The \FlowExecutor\ iterates through defined \FlowStep\s, using a \ReActEngine\ to determine actions and parse LLM responses via regex patterns. The system supports persistent state management through \FlowStatusProvider\, which saves and restores execution state and chat history to an \IMemoryStore\. New data models (\Flow\, \FlowStep\, \ReActStep\) define step goals, plugin requirements, and completion types (Once, AtLeastOnce, ZeroOrMore), while \ChatHistorySerializer\ handles JSON serialization of conversation history for state recovery.

dotnet/src/Experimental/Orchestration.Flow/Execution · high confidence

The Handlebars prompt template engine now supports calling Semantic Kernel functions directly from templates via helpers registered as \PluginName.FunctionName\. This allows templates to execute kernel logic and receive results, with optional HTML encoding for safety when \allowDangerouslySetContent\ is disabled. Additionally, new system helpers (\set\, \json\, \concat\, \array\, \raw\, \range\, \or\, \add\, \subtract\, \equals\) enable variable assignment, JSON serialization, string/array manipulation, and arithmetic within templates, while utility logic ensures proper argument resolution from the kernel context and type validation for function parameters.

dotnet/src/Extensions/PromptTemplates.Handlebars/Helpers · high confidence

Users can now use Handlebars syntax for prompt templates in .NET via the new HandlebarsPromptTemplateFactory. This adds built-in helpers for math and string manipulation, allows registering custom helpers, and introduces an EnableHtmlDecoder option (defaulting to true) to control whether rendered output is HTML-decoded, alongside an AllowDangerouslySetContent flag to manage prompt injection safety for complex types.

dotnet/src/Extensions/PromptTemplates.Handlebars · high confidence

Users can now use Liquid syntax for prompt templates via the new LiquidPromptTemplate and LiquidPromptTemplateFactory. The implementation parses Liquid templates using the Fluid library and, when rendering, automatically converts text patterns like 'user: message' into structured \<message role="user"\> tags to support chat history formatting. To mitigate prompt injection risks, input content is HTML-encoded by default; this behavior can be disabled by setting AllowDangerouslySetContent to true, which is recommended only for non-chat AI services like Text-To-Image.

dotnet/src/Extensions/PromptTemplates.Liquid · high confidence

Adds a new experimental local runtime for executing Semantic Kernel processes in-process, providing the \LocalKernelProcessFactory\ to start and run processes via \StartAsync\ and \RunToEndAsync\. This runtime includes the \LocalKernelProcessContext\ for managing process lifecycle (sending events, stopping, retrieving state) and implements core execution components such as \LocalProcess\ for orchestration, \LocalStep\ as the base for step execution, \LocalAgentStep\ for handling agent-based steps with error handling and declarative conditions, \LocalMap\ for parallel map operations, \LocalProxy\ for external message channel integration, and \LocalEdgeGroupProcessor\ for coordinating grouped message inputs.

dotnet/src/Experimental/Process.LocalRuntime · high confidence

This change adds the internal client implementation for the new MistralAI connector, introducing the \MistralClient\ class and a suite of request/response models (such as \ChatCompletionRequest\, \ChatCompletionResponse\, and \MistralChatMessage\) to handle chat completions and text embeddings. The client supports streaming responses, tool/function calling with automatic invocation, and multi-modal content including text, images, and documents via dedicated chunk types like \ImageUrlChunk\ and \DocumentUrlChunk\. It also integrates with Semantic Kernel's diagnostic and logging infrastructure to track token usage and activity traces.

dotnet/src/Connectors/Connectors.MistralAI/Client · high confidence

Added the MistralAI connector services, including \MistralAIChatCompletionService\ for chat completions and \MistralAIEmbeddingGenerator\ for text embeddings. The legacy \MistralAITextEmbeddingGenerationService\ is now obsolete and users should migrate to the new embedding generator.

dotnet/src/Connectors/Connectors.MistralAI/Services · high confidence

Added the TextSearchProvider component, which integrates with the AI model invocation pipeline to inject search results as context. Users can configure the provider via TextSearchProviderOptions to control the number of results (Top), apply filters, and choose between automatic pre-invocation search (BeforeAIInvoke) or on-demand function calling (OnDemandFunctionCalling). The component also supports customizing the context prompt, citation instructions, and result formatting, allowing for flexible retrieval-augmented generation (RAG) behaviors within Semantic Kernel.

dotnet/src/SemanticKernel.Core/Data/TextSearchBehavior · high confidence

This change adds the core abstraction layer for declarative agents in the Semantic Kernel .NET SDK. It introduces the \AgentDefinition\ class to model agent configuration (including ID, type, name, instructions, model, tools, inputs, and outputs) and the \AgentFactory\ abstract class to handle the creation of \Agent\ instances from these definitions. Supporting types include \AgentCreationOptions\ for factory parameters, \AgentInput\ and \AgentOutput\ for defining data schemas, \AgentToolDefinition\ for tool metadata, \ModelDefinition\ and \ModelConnection\ for specifying the AI model and its connection details, \AgentMetadata\ for author/tag information, and \AggregatorAgentFactory\ to chain multiple factories together. These types are marked with the \SKEXP0110\ experimental attribute.

dotnet/src/Agents/Abstractions/Definition · high confidence

The Google connector now includes new internal client classes, GeminiChatCompletionClient and GeminiTokenCounterClient, which handle chat completion and token counting operations for both GoogleAI and VertexAI backends. These clients manage API versioning, authentication (API keys and bearer tokens), and endpoint construction, providing a structured foundation for Gemini model interactions within the connector.

dotnet/src/Connectors/Connectors.Google/Core/Gemini/Clients · high confidence

Adds a new experimental \Process.Core\ library (marked with \SKEXP0080\) that provides the foundational building blocks for defining and managing AI agent workflows. This includes the \ProcessBuilder\ for orchestrating steps, \ProcessAgentBuilder\ for integrating agents, and fluent builders for defining edges, event listeners (\ListenForBuilder\), and state management. The library also introduces support for parallel processing via \ProcessMapBuilder\, external event publishing through \ProcessProxyBuilder\, and backward-compatible state migration when step names or versions change.

dotnet/src/Experimental/Process.Core · high confidence

This change adds the Flow Orchestrator component to the Semantic Kernel experimental library, enabling users to define, validate, and execute complex, multi-step AI workflows (flows) composed of sequential or referenced steps. The new \FlowOrchestrator\ class coordinates execution using a \FlowExecutor\, while \FlowValidator\ enforces structural rules such as partial ordering, required starting messages for optional steps, and constraints on reference steps. Users can manage flows via the \IFlowCatalog\ interface (registering and retrieving flows) and persist execution state, chat history, and ReAct reasoning steps through the \IFlowStatusProvider\. Flows are defined and serialized using YAML or JSON via \FlowSerializer\, and execution behavior is configurable through \FlowOrchestratorConfig\, which allows tuning token limits, variable lengths, iteration counts, auto-termination, and AI service settings.

dotnet/src/Experimental/Orchestration.Flow · high confidence

Adds the \Process.Abstractions\ library, providing the foundational types for defining and managing Kernel Processes. This includes core models like \KernelProcess\ and \KernelProcessStep\, state management via \KernelProcessStepState\, and event handling through \KernelProcessEvent\ and \KernelProcessEdge\. The package also introduces interfaces for internal and external messaging (\IKernelProcessMessageChannel\, \IExternalKernelProcessMessageChannel\) and context classes (\KernelProcessContext\, \KernelProcessStepContext\) to facilitate step execution and event emission. Marked as experimental with the ID \SKEXP0080\.

dotnet/src/Experimental/Process.Abstractions · high confidence

The memory plugin functionality is now available as a standalone package (\dotnet/src/Plugins/Plugins.Memory\) containing the \TextMemoryPlugin\ for saving, recalling, and searching semantic memories, along with a \VolatileMemoryStore\ for in-memory embedding storage. The plugin exposes kernel functions for key-based retrieval, semantic search with relevance scoring, and memory management, while the memory store utilizes a min-heap for efficient top-N similarity matching. Both components are marked as experimental via the \SKEXP0001\ and \SKEXP0050\ attributes.

dotnet/src/Plugins/Plugins.Memory · high confidence

This change adds the internal implementation details for the new Azure AI Agent support, including the \AgentMessageFactory\ for translating chat messages and attachments, the \AgentThreadActions\ class handling thread creation, message posting, and run invocation/polling, and dedicated logging extensions for both agent and thread actions. These components form the backend runtime that enables the \AzureAIAgent\ to interact with the Azure AI Agents service.

dotnet/src/Agents/AzureAI/Internal · high confidence

This change adds a new set of internal utility classes in the process abstractions layer to support the underlying process engine. It introduces a declarative condition evaluator that supports both JMESPath expressions and property-based comparisons for controlling process flow, as well as a state manager for handling process state reduction and deep-copying. Additionally, it provides extension methods for cloning processes, maps, and steps, and factories for converting process states into metadata structures, laying the groundwork for stateful process execution and error handling.

dotnet/src/InternalUtilities/process/Abstractions · high confidence

Adds a new agent orchestration framework in the \dotnet/src/Agents/Orchestration\ directory, enabling developers to coordinate multiple agents through structured patterns. This includes a \ConcurrentOrchestration\ for broadcasting inputs to parallel agents and a \GroupChatOrchestration\ for managing turn-based team interactions via a configurable \GroupChatManager\. The implementation provides base classes for input/output transformation, streaming response callbacks, and runtime integration, allowing users to define complex, multi-step agent workflows.

dotnet/src/Agents/Orchestration · high confidence

Added \CodeTokenizer\ and \TemplateTokenizer\ classes to the \TemplateEngine\ namespace to handle parsing of Semantic Kernel template syntax. \TemplateTokenizer\ identifies blocks delimited by \{{\ and \}}\, while \CodeTokenizer\ parses the internal structure of code blocks (variables, values, and function calls) according to a defined BNF grammar. These components replace previous inline parsing logic, providing a structured way to extract and validate template content.

dotnet/src/SemanticKernel.Core/TemplateEngine · high confidence

This change introduces the core abstractions for the new Semantic Kernel Agent Framework, establishing the foundational types for building and managing AI agents. It adds the \Agent\ base class for defining agent identity, instructions, and invocation protocols, along with \AgentChannel\ to handle communication and state synchronization between agents and chats. The \AgentChat\ class provides the orchestration layer for multi-agent conversations, supporting message history, streaming, and serialization. Additionally, it includes \AggregatorAgent\ to allow one chat to participate within another, \AgentThread\ for conversation lifecycle management, and extension methods to expose Semantic Kernel agents as Microsoft Agent Framework \AIAgent\ instances.

dotnet/src/Agents/Abstractions · high confidence

This change adds a new set of extension methods in the \Microsoft.SemanticKernel.Experimental.Orchestration\ namespace to support the Flow Orchestrator feature. \FlowExtensions\ provides logic to sort flow steps by dependency and to hydrate reference flows by resolving and merging them into the main flow. \KernelArgumentsExtensions\ and \FunctionResultExtensions\ introduce helper methods to control execution flow, such as prompting for user input, continuing or exiting loops, and terminating the flow based on metadata flags. Additionally, \ExceptionExtensions\ adds logic to identify non-retryable content filter errors, and \PromptTemplateConfigExtensions\ allows setting the \max\_tokens\ parameter for OpenAI models.

dotnet/src/Experimental/Orchestration.Flow/Extensions · high confidence

The \AgentGroupChat\ component now supports pluggable strategies to control how agents are selected and when the chat loop terminates. Users can configure a \SelectionStrategy\ (defaulting to \SequentialSelectionStrategy\ for round-robin turn-taking) and a \TerminationStrategy\ (defaulting to a single-iteration no-termination rule). New built-in strategies include \KernelFunctionSelectionStrategy\ and \KernelFunctionTerminationStrategy\, which allow agent selection and termination decisions to be driven by the evaluation of arbitrary \KernelFunction\s, and \RegexTerminationStrategy\, which terminates based on regular expression matches against the latest message. Additionally, \AggregatorTerminationStrategy\ enables combining multiple termination conditions using logical 'All' or 'Any' modes. These strategies are configured via \AgentGroupChatSettings\ and are fully instrumented with structured logging for debugging and observability.

dotnet/src/Agents/Core/Chat · high confidence

This change adds a new set of internal HTTP utilities in the \dotnet/src/InternalUtilities/src/Http\ directory. Key additions include \PublicNetworkAddressValidator\, which blocks requests to private, loopback, or link-local IP addresses to prevent Server-Side Request Forgery (SSRF) attacks, and \HttpClientProvider\, which manages \HttpClient\ instances with configurable redirect behavior and connection lifetime settings. The library also introduces \HttpClientExtensions\ and \HttpContentExtensions\ to standardize HTTP request execution and response reading, ensuring that \HttpRequestException\s are consistently translated into \HttpOperationException\s for uniform error handling. Additionally, \HttpHeaderConstant\ centralizes header definitions, including the new \Semantic-Kernel-Version\ header, and \HttpRequest\ provides helper methods for creating typed HTTP requests with JSON payloads.

dotnet/src/InternalUtilities/src/Http · high confidence

This change adds a set of internal utility classes in the process runtime that enable the execution of AI agents within a kernel process and manage the underlying message flow. Specifically, it introduces factories to create agent instances (supporting Azure AI, OpenAI, and ChatCompletion types) and their associated threads, as well as an executor step that handles agent invocation, state persistence, and message wrapping. Additionally, it defines the core data structures for process communication, including \ProcessMessage\ and \ProcessEvent\ records, along with factories to construct these messages from process edges and handle map-operation data serialization.

dotnet/src/InternalUtilities/process/Runtime · high confidence

The SemanticKernel.Abstractions library now includes a new abstraction for audio-to-text capabilities, defined by the \IAudioToTextService\ interface and the \AudioToTextServiceExtensions\ helper class within the \Microsoft.SemanticKernel.AudioToText\ namespace. This addition allows users to integrate audio transcription services, such as OpenAI's implementation, into their kernels. The interface supports returning multiple text content results from a single audio input, and the extension method provides a convenient way to retrieve a single text result.

dotnet/src/SemanticKernel.Abstractions/AI/AudioToText · high confidence

The SemanticKernel.Core package now includes a new KernelExtensions class that provides extension methods for the Kernel, specifically for creating functions from methods (CreateFunctionFromMethod) and from prompts (CreateFunctionFromPrompt). These methods allow users to define custom logic or prompt-based functions directly on the Kernel instance. Additionally, a CompatibilitySuppressions.xml file has been added to support package validation, ensuring that breaking changes or API surface modifications are tracked and managed according to Microsoft's package validation standards.

dotnet/src/SemanticKernel.Core · high confidence

The SemanticKernel.Abstractions package now includes a new \ITextToAudioService\ interface and corresponding extension methods within the \Microsoft.SemanticKernel.TextToAudio\ namespace. This change introduces the foundational abstraction for text-to-audio capabilities, allowing users to generate audio content from text via the \GetAudioContentsAsync\ method, which returns a list of \AudioContent\ objects. The implementation is marked with the \SKEXP0001\ experimental flag, indicating it is an early-stage feature.

dotnet/src/SemanticKernel.Abstractions/AI/TextToAudio · high confidence

The SemanticKernel.Abstractions package now includes a new \ITextToImageService\ interface and corresponding extension methods within the \Microsoft.SemanticKernel.TextToImage\ namespace. This change introduces the foundational API for text-to-image capabilities, allowing developers to generate images from text prompts using the \GetImageContentsAsync\ method or the convenience \GenerateImageAsync\ extension. The interface is marked as experimental (\SKEXP0001\) and supports execution settings for parameters like image dimensions.

dotnet/src/SemanticKernel.Abstractions/AI/TextToImage · high confidence

The \dotnet/src/SemanticKernel.Core/Functions\ directory now contains the core implementation for creating and managing Kernel functions and plugins. This includes \KernelFunctionFactory\ for creating functions from methods or prompts, \KernelFunctionFromMethod\ and \KernelFunctionFromPrompt\ for the specific function types, and \KernelPluginFactory\ for creating plugins from types or objects. The \DefaultKernelPlugin\ class provides the underlying storage and retrieval logic for functions within a plugin, including support for AI function discovery via \AIFunction\. These changes represent a structural shift in how functions and plugins are instantiated and managed within the Semantic Kernel.

dotnet/src/SemanticKernel.Core/Functions · high confidence

The MistralAI connector now supports function calling via the new \MistralAIToolCallBehavior\ class, allowing developers to enable kernel functions, require specific functions, or auto-invoke them. Additionally, \MistralAIPromptExecutionSettings\ has been introduced to expose model parameters such as temperature, top\_p, max\_tokens, safe\_prompt, random\_seed, and response\_format, giving users finer control over chat completion behavior.

dotnet/src/Connectors/Connectors.MistralAI · high confidence

The MongoDB connector now supports Guid, ObjectId, and DateOnly types for record keys and data properties. This allows users to define vector store models using these types as primary keys or data fields, with automatic mapping to MongoDB's BSON representation (e.g., GuidStandardRepresentation for Guids) and validation of supported key types.

dotnet/src/InternalUtilities/connectors/Memory · high confidence

A new demo application has been added to the .NET samples that demonstrates how to configure Semantic Kernel to send telemetry (logs, traces, and metrics) to Azure Application Insights using OpenTelemetry. The sample includes a console application that exercises chat completion and tool calling across multiple providers (Azure OpenAI, Google Gemini, Hugging Face, Mistral AI, and Azure AI Inference) and documents the required configuration steps, including setting up secrets and querying results in Azure Monitor.

dotnet/samples/Demos/TelemetryWithAppInsights · high confidence

Added a new sample demonstrating the Agent-to-Agent (A2A) protocol using the SharpA2A.Core library. The \A2AServer\ component exposes three distinct agents (Invoice, Policy, and Logistics) via the A2A protocol, supporting both Azure AI Foundry and OpenAI chat completion backends, while the \A2AClient\ component acts as a command-line interface that connects to these remote agents to execute queries.

dotnet/samples/Demos/A2AClientServer · high confidence

Added a new console application sample in dotnet/samples/Demos/AIModelRouter that demonstrates how to route AI requests to different model providers based on user input. The sample registers multiple chat completion services—including LMStudio, Ollama, Azure OpenAI, OpenAI, ONNX, and Azure AI Inference—and uses a custom keyword-based router to select the appropriate service. It also includes a filter to log the selected service ID, allowing users to see which backend handles each prompt.

dotnet/samples/Demos/AIModelRouter · high confidence

Users can now directly invoke Agents as standard KernelFunctions or group them into a KernelPlugin. The new \AgentKernelFunctionFactory.CreateFromAgent\ method wraps an Agent into a function that accepts a 'query' and optional 'instructions', while \AgentKernelPluginFactory.CreateFromAgents\ allows bundling multiple agents into a single plugin for easier discovery and invocation within the Semantic Kernel.

dotnet/src/Agents/Core/Functions · high confidence

The AgentFrameworkMigration sample area now includes side-by-side migration examples showing how to translate Semantic Kernel agent patterns to the new Agent Framework. This includes samples for concurrent and sequential orchestrations, handoff workflows, and Azure AI Foundry and Azure OpenAI agent scenarios (basic usage, tool calls, dependency injection, and code interpreter). Each sample demonstrates the equivalent implementation in both Semantic Kernel and the Agent Framework, helping developers understand the API differences and migration paths for agent orchestration and tool integration.

dotnet/samples/AgentFrameworkMigration · high confidence

Added a new set of ten C\# sample files (Step01 through Step10) in the GettingStartedWithAgents/AzureAIAgent directory that demonstrate how to use the Azure AI Agent service via the Semantic Kernel SDK. These samples cover creating agents from templates, integrating plugins and prompt functions, handling vision inputs, using code interpreter and file search tools, invoking OpenAPI specifications, defining function tools, declarative agent creation via YAML, Bing grounding with streaming, and enforcing structured JSON responses.

dotnet/samples/GettingStartedWithAgents/AzureAIAgent · high confidence

Added a new sample project at dotnet/samples/GettingStartedWithAgents/BedrockAgent that demonstrates how to use AWS Bedrock Agents with Semantic Kernel. The samples cover creating and invoking agents, using code interpreters, integrating kernel functions (including complex types), enabling streaming responses, inspecting orchestration traces, associating knowledge bases for file search, and orchestrating multi-agent chats. A declarative agent sample also shows how to configure and instantiate agents via YAML.

dotnet/samples/GettingStartedWithAgents/BedrockAgent · high confidence

The Contents folder now includes BinaryContentExtensions, which adds a WriteToFile method to save binary content directly to disk, and StreamingMethodContent, a new class that wraps a single function result for streaming scenarios, converting non-byte-array content to UTF-8 bytes by default.

dotnet/src/SemanticKernel.Core/Contents · high confidence

The Web plugins package now includes new Bing and Brave search connectors (\BingConnector\, \BraveConnector\) and corresponding \BingTextSearch\ and \BraveTextSearch\ implementations. These allow users to perform web searches via the Bing Web Search API and Brave Search API, respectively. Both implementations support the generic \ITextSearch\<TRecord\>\ interface, enabling type-safe LINQ-based filtering (e.g., filtering by language, title, or freshness) that is automatically translated into API-specific query parameters. The plugins also expose options for custom endpoints, HTTP clients, and result mappers.

dotnet/src/Plugins/Plugins.Web · high confidence

Added a new console application sample in dotnet/samples/Demos/BookingRestaurant that demonstrates Semantic Kernel function calling against the Microsoft Graph Bookings API. The app supports both OpenAI and Azure OpenAI chat completion, and Azure Entra ID authentication (interactive browser or app secret). It exposes a BookingsPlugin with functions to list reservations, cancel reservations, and book a table; the BookTable function requires explicit user confirmation ('yes'/'no') before submitting the appointment to Graph.

dotnet/samples/Demos/BookingRestaurant · high confidence

A new sample application demonstrating an AI agent framework integrated with .NET Aspire. The solution includes an API service that exposes an agent completion endpoint supporting both standard and streaming responses, and a Blazor web frontend for user interaction. The architecture leverages Aspire for orchestration, configuring upstream dependencies such as Azure OpenAI or OpenAI for chat and embeddings, and Azure AI Search for Retrieval-Augmented Generation (RAG). The demo includes configuration models for selecting AI providers and vector stores, along with embedded agent definitions using Handlebars templates.

dotnet/samples/Demos/AgentFrameworkWithAspire · high confidence

This change introduces new experimental connectors for the Chroma and Milvus vector databases, providing full implementations of the IMemoryStore interface (including collection management, embedding upsert/get/delete, and similarity search) along with MemoryBuilder extension methods for easy integration. Simultaneously, the repository has been reorganized to reflect the migration of several other vector data providers (Azure AI Search, Cosmos DB, In-Memory, PgVector, Qdrant, Redis, and SQL Server) to external repositories (CommunityToolkit/AI or MongoDB), with the local directories now containing only redirect READMEs. The Pinecone connector has been permanently removed due to the archiving of its .NET SDK.

dotnet/src/VectorData · high confidence

Added a new .NET demo application that showcases the SessionsPythonPlugin, enabling AI-driven code execution via Azure Container Apps Session Pools. The sample demonstrates configuring the plugin with specific security controls (such as allowed domains and disabled file uploads by default), integrating with OpenAI chat completion using automatic function calling, and handling interactive user sessions with token caching for Azure authentication.

dotnet/samples/Demos/CodeInterpreterPlugin · high confidence

Added a new .NET sample application in \dotnet/samples/Demos/ContentSafety\ that demonstrates integrating Azure AI Content Safety and Prompt Shields with Semantic Kernel. The demo includes a chat controller and middleware filters (\TextModerationFilter\, \AttackDetectionFilter\) that analyze user prompts and documents for offensive content and jailbreak attacks before they reach the LLM, returning 400 Bad Request responses when violations are detected.

dotnet/samples/Demos/ContentSafety · high confidence

Added a new experimental plugin in the Plugins.AI area that integrates with the CrewAI Enterprise API. This allows users to kick off AI crews, retrieve their status, and wait for completion via the \CrewAIEnterprise\ class, which exposes \KernelFunction\ wrappers for seamless integration into Semantic Kernel workflows. The implementation includes an HTTP client for API communication, models for request/response handling, and a JSON converter for state enumeration.

dotnet/src/Plugins/Plugins.AI · high confidence

The demo server now provides new extension methods on \IMcpServerBuilder\ to simplify registering Semantic Kernel plugins as MCP tools, and to declaratively register prompts, resources, and resource templates via dependency injection. The \WithTools\ method automatically discovers \KernelPlugin\ instances from the DI container and exposes their functions as MCP tools, while \WithPrompt\, \WithResource\, and \WithResourceTemplate\ register definitions in the DI container and wire up the necessary list/read handlers. Additionally, a new \VectorStoreExtensions\ class adds a helper to create vector store collections from a list of strings, automatically generating embeddings using an \IEmbeddingGenerator\ and upserting the resulting records.

dotnet/samples/Demos/ModelContextProtocolClientServer/MCPServer/Extensions · high confidence

This change introduces a new ASP.NET Core application in the \Process.IntegrationTestHost.Dapr\ project to serve as a shared, cross-runtime integration test host for Semantic Kernel processes. It exposes HTTP endpoints to start processes, retrieve their state, and inspect mock cloud event clients, while registering Dapr actors and a custom JSON type resolver to handle polymorphic process step states. This host enables end-to-end testing of process execution logic against a Dapr runtime environment.

dotnet/src/Experimental/Process.IntegrationTestHost.Dapr · high confidence

This change introduces a new experimental plugin (marked with SKEXP0050) in the \dotnet/src/Plugins/Plugins.StructuredData.EntityFramework\ package that enables Semantic Kernel to perform CRUD operations against Entity Framework databases. The plugin provides a \StructuredDataService\ and a \StructuredDataPluginFactory\ that dynamically creates Kernel functions for Select, Insert, Update, and Delete operations on specified entity types. The Select function supports OData filter expressions (leveraging the OData2Linq library) to query records, while the other functions allow inserting, updating, and deleting entities, returning the affected rows or the entity itself as appropriate.

dotnet/src/Plugins/Plugins.StructuredData.EntityFramework · high confidence

Added a new F\# script sample (huggingFaceChatCompletion.fsx) in the Demos folder that demonstrates how to integrate the Microsoft.SemanticKernel.Connectors.HuggingFace connector (version 1.12.0-preview) to perform chat completions using the Phi-3-mini-4k-instruct model via the Hugging Face Inference API. The script includes setup for dependency injection, HTTP logging, and a simple interactive console loop for asking questions.

dotnet/samples/Demos/FSharpScripts · high confidence

Added a new console application sample in dotnet/samples/Demos/FunctionInvocationApproval that demonstrates how to use the IFunctionInvocationFilter to require explicit approval before a Kernel Function is executed. The demo includes a SoftwareBuilderPlugin with stages for requirements, design, implementation, testing, and deployment, and uses a ConsoleFunctionApprovalService to prompt the user for approval via the console, allowing the LLM to react to rejected invocations. It supports configuration for both OpenAI and Azure OpenAI chat completion services.

dotnet/samples/Demos/FunctionInvocationApproval · high confidence

The Google connector now includes new \GoogleAIEmbeddingGenerator\ and \VertexAIEmbeddingGenerator\ classes that implement the modern \IEmbeddingGenerator\ interface, allowing users to optionally specify the number of embedding dimensions. The legacy \ITextEmbeddingGenerationService\ implementations (\GoogleAITextEmbeddingGenerationService\ and \VertexAITextEmbeddingGenerationService\) are now obsolete and delegate to these new generators. Additionally, new \GoogleAIGeminiChatCompletionService\ and \VertexAIGeminiChatCompletionService\ classes are introduced to provide chat completion capabilities for Gemini models, supporting both static API keys and dynamic bearer token providers.

dotnet/src/Connectors/Connectors.Google/Services · high confidence

The Google Gemini connector now includes a set of new model classes in the Models/Gemini directory to support advanced features. GeminiChatMessageContent and GeminiStreamingChatMessageContent handle chat interactions, including tool calls and results, with support for FunctionChoiceBehavior and ThoughtSignature preservation for thinking-enabled models. GeminiFunction and related classes define function parameters and declarations for tool use. GeminiMetadata exposes detailed token usage statistics, including CachedContentTokenCount and ThoughtsTokenCount, as well as safety ratings and finish reasons. New structs like GeminiFinishReason, GeminiSafetyCategory, GeminiSafetyProbability, and GeminiSafetyThreshold provide strongly-typed, JSON-serializable representations of Gemini's safety and completion states.

dotnet/src/Connectors/Connectors.Google/Models · high confidence

A new step-by-step sample project has been added to demonstrate how to use Vector Stores in Semantic Kernel. It guides users through ingesting data, performing vector searches with and without filters, switching between different backends (InMemory, Azure AI Search, and Redis), and using dynamic data modeling. The sample includes a strongly-typed Glossary model and a test fixture that sets up an Azure OpenAI embedding generator, providing a practical reference for integrating vector search capabilities into applications.

dotnet/samples/GettingStartedWithVectorStores · high confidence

Added a new \GettingStartedWithTextSearch\ sample project that demonstrates how to use Semantic Kernel's text search features. The sample includes step-by-step examples for performing web searches via Bing and Google, implementing Retrieval Augmented Generation (RAG) with search plugins, using function calling to ground LLM responses, and leveraging in-memory vector stores for semantic search. It also provides the necessary test fixtures and configuration guidance to run these integration tests locally.

dotnet/samples/GettingStartedWithTextSearch · high confidence

A new sample project has been added to guide users through the Semantic Kernel Agent framework. It includes step-by-step examples for creating and using ChatCompletion agents, associating plugins (such as the new MenuPlugin and WidgetFactory), managing conversation history with threads, and orchestrating multi-agent interactions via AgentGroupChat with various strategies (termination, selection, and kernel function-based). The samples also demonstrate advanced features like JSON result parsing, dependency injection patterns for agents, and enabling telemetry (logging and tracing) for both ChatCompletion and OpenAI Assistant agents.

dotnet/samples/GettingStartedWithAgents · high confidence

A new sample plugin has been added to the LearnResources section that demonstrates how to integrate with the GitHub REST API using Semantic Kernel. The \GitHubPlugin\ class exposes kernel functions to retrieve user profiles, repository details, and filtered issue lists, while \GitHubModels\ provides the necessary data structures for deserializing API responses. This sample illustrates how to configure an HTTP client with authentication headers and construct relative URIs for API calls.

dotnet/samples/LearnResources/Plugins/GitHub · high confidence

A new HomeAutomation demo application has been added to the .NET samples, illustrating how to integrate Semantic Kernel with .NET's built-in dependency injection. The sample configures OpenAI or Azure OpenAI services via options, registers custom plugins (such as MyLightPlugin and MyAlarmPlugin) as singletons or keyed services, and uses a BackgroundService (Worker) to run an interactive chat loop with auto function calling enabled. It includes VS Code launch and task configurations for easy local development.

dotnet/samples/Demos/HomeAutomation · high confidence

A new Windows Forms sample application has been added to demonstrate the HuggingFace Image-to-Text capability. The app allows users to select a local folder of images, displays them in a grid, and generates descriptive text for any clicked image using the Salesforce BLIP model via the Semantic Kernel HuggingFace connector.

dotnet/samples/Demos/HuggingFaceImageToText · high confidence

This change introduces four new service implementations in the HuggingFace connector: HuggingFaceChatCompletionService for chat completions, HuggingFaceTextGenerationService for text generation, HuggingFaceEmbeddingGenerator for embedding generation, and HuggingFaceImageToTextService for image-to-text conversion. All services support optional endpoint configuration and optional API keys, allowing users to connect to custom HuggingFace inference endpoints. Additionally, the legacy HuggingFaceTextEmbeddingGenerationService is marked as obsolete in favor of the new HuggingFaceEmbeddingGenerator.

dotnet/src/Connectors/Connectors.HuggingFace/Services · high confidence

The SemanticKernel.Abstractions library now includes a new \IImageToTextService\ interface and corresponding \ImageToTextExtensions\ within the \Microsoft.SemanticKernel.ImageToText\ namespace. This introduces the foundational contract for image-to-text capabilities, allowing services to implement \GetTextContentsAsync\ to extract text from images, along with a convenience extension method \GetTextContentAsync\ for retrieving a single result. These components are marked with the \SKEXP0001\ experimental flag, indicating they are part of the experimental feature set for multi-modal image processing.

dotnet/src/SemanticKernel.Abstractions/AI/ImageToText · high confidence

A new sample server has been added to the ModelContextProtocolClientServer demo that registers Semantic Kernel plugins as MCP tools, exposes a custom prompt definition, and implements a vector store resource template for retrieving records based on user queries. The server also includes a static image resource and demonstrates how to configure an agent as a plugin, providing a complete example of integrating Semantic Kernel capabilities with the Model Context Protocol.

dotnet/samples/Demos/ModelContextProtocolClientServer/MCPServer · high confidence

The MCPClient demo now includes a comprehensive set of samples demonstrating Model Context Protocol usage, including tools, prompts, resources, resource templates, and sampling interactions. A new HumanInTheLoopFilter class has been added to intercept MCP sampling handler invocations, allowing for user approval or rejection of requests (currently implemented as a placeholder that always approves) to handle sensitive data scenarios. The application entry point has been updated to run all these individual sample scenarios sequentially.

dotnet/samples/Demos/ModelContextProtocolClientServer/MCPClient · high confidence

Added a suite of new sample files in the MCPClient/Samples directory that demonstrate how to integrate the Model Context Protocol (MCP) with Semantic Kernel. These samples cover using MCP tools as Kernel functions, invoking MCP prompts and resources, handling MCP sampling requests with human-in-the-loop filters, and integrating MCP tools with both ChatCompletionAgent and AzureAIAgent. A shared BaseSample class provides common utilities for creating MCP clients, kernels, and displaying available MCP items.

dotnet/samples/Demos/ModelContextProtocolClientServer/MCPClient/Samples · high confidence

Added a new sample demonstrating a map-reduce workflow using the KernelProcess API. The sample defines a process that chunks input text, counts word frequencies in parallel (map), and aggregates the results to display the top 10 most frequent words (reduce).

dotnet/samples/GettingStartedWithProcesses/Step05 · high confidence

The SemanticKernel.Core/Memory location now includes the core components for the Memory plugin: a new \MemoryBuilder\ class to configure memory stores and embedding generation services, a \SemanticTextMemory\ implementation that supports both the legacy \ITextEmbeddingGenerationService\ and the newer \IEmbeddingGenerator\<string, Embedding\<float\>\>\ interfaces, and an \AIContextExtensions\ class to register AI context functions as kernel plugins.

dotnet/src/SemanticKernel.Core/Memory · high confidence

The ONNX connector now provides new registration extensions for configuring BERT-based text embedding generation and OnnxRuntimeGenAI chat completions via dependency injection. Users can add a BERT embedding generator using the new \AddBertOnnxEmbeddingGenerator\ extension (which registers \IEmbeddingGenerator\), while the older \AddBertOnnxTextEmbeddingGeneration\ is now obsolete. For chat completions, the connector introduces \AddOnnxRuntimeGenAIChatCompletion\ and \AddOnnxRuntimeGenAIChatClient\ extensions, allowing users to register \IChatCompletionService\ or \IChatClient\ backed by an ONNX model path, with optional support for specifying hardware providers and custom prompt formatting.

dotnet/src/Connectors/Connectors.Onnx · high confidence

Added a new .NET sample application demonstrating how to use the Ollama connector with Semantic Kernel to enable function calling. The demo includes a console-based chat loop that interacts with a local Ollama instance (defaulting to llama3.2) and utilizes three custom plugins: MyTimePlugin for retrieving the current time, MyLightPlugin for toggling a light state, and MyAlarmPlugin for setting and querying alarms.

dotnet/samples/Demos/OllamaFunctionCalling · high confidence

This location introduces the \OpenAIAssistantAgent\ and \OpenAIResponseAgent\ classes, providing new agent specializations that leverage the OpenAI Assistants and Responses APIs respectively. The \OpenAIAssistantAgent\ includes a dedicated \ClientFactory\ for creating \AzureOpenAIClient\ and \OpenAIClient\ instances with custom HTTP transport and retry policies, while the \OpenAIResponseAgent\ supports the newer Responses API with streaming capabilities. Both agents integrate with the Semantic Kernel agent framework, supporting features like prompt templates, AI context providers, and intermediate message callbacks, and are exposed as \Microsoft.Agents.AI.AIAgent\ via extension methods.

dotnet/src/Agents/OpenAI · high confidence

Added seven new C\# test samples in the GettingStartedWithAgents/OpenAIAssistant directory demonstrating how to use OpenAIAssistantAgent with templated instructions, KernelPlugins, image/vision input, code interpreter, file search, function tools, and declarative YAML configuration.

dotnet/samples/GettingStartedWithAgents/OpenAIAssistant · high confidence

Added four new sample files in the GettingStartedWithAgents/OpenAIResponse directory that demonstrate the OpenAIResponseAgent. Step01 covers basic invocation, streaming, threaded conversations, and image content. Step02 shows how to manage conversation state manually and via the agent's store. Step03 illustrates using reasoning models (o4-mini) with configurable effort levels. Step04 demonstrates integrating tools, including function calling, web search, and file search with vector stores.

dotnet/samples/GettingStartedWithAgents/OpenAIResponse · high confidence

The OpenAI connector now includes dedicated service implementations for core capabilities: \OpenAIChatCompletionService\ handles chat and text generation (including streaming), \OpenAITextToAudioService\ and \OpenAIAudioToTextService\ manage audio conversion, \OpenAITextToImageService\ generates images using the \gpt-image-1\ model by default, and \OpenAIFileService\ provides file upload and retrieval. Several of these services, including the embedding and file services, are marked as obsolete or experimental, directing users toward newer SDK-based extension methods or client patterns.

dotnet/src/Connectors/Connectors.OpenAI/Services · high confidence

The OpenAPI plugin integration now exposes \OpenApiFunctionExecutionParameters\ to allow users to configure HTTP client behavior, authentication callbacks, server URL validation (enabled by default to prevent SSRF), dynamic payload construction, and operation selection predicates. Additionally, \OpenApiKernelExtensions\ provides new \ImportPluginFromOpenApiAsync\ and \CreatePluginFromOpenApiAsync\ methods on the \Kernel\ class, simplifying the process of loading and registering OpenAPI plugins directly into the kernel.

dotnet/src/Functions/Functions.OpenApi/Extensions · high confidence

A new sample demonstrating how to use the OpenAPI plugin capability has been added to the concepts directory. It includes a simple aiohttp-based server and a client script that loads an OpenAPI 3.1.0 specification to register a plugin and invoke operations. The sample also provides a README with instructions for running the server and client using the uv tool.

python/samples/concepts/plugins/openapi · high confidence

A new PlanCreationException class has been added to the planning utilities, inheriting from KernelException. This exception now carries the original prompt template (CreatePlanPrompt) and the model's completion results (ModelResults) when a plan cannot be created, allowing users to inspect the context and proposed output that led to the failure.

dotnet/src/InternalUtilities/planning/Exceptions · high confidence

Added a new sample demonstrating how to use the Semantic Kernel Process Framework with SignalR for real-time cloud event communication. The demo includes a .NET backend that orchestrates a document generation process (gathering info, generating docs, proofreading, and publishing) and exposes a SignalR hub to push events like document review requests and published documents to a React frontend. The frontend allows users to initiate document generation and interact with the process in real-time via SignalR.

dotnet/samples/Demos/ProcessFrameworkWithSignalR · high confidence

Added a new sample demonstrating how to use Semantic Kernel function invocation filters to evaluate LLM-generated text for summarization and translation tasks. The demo implements filters for BERTScore, BLEU, METEOR, and COMET metrics that automatically score results against configurable thresholds and throw exceptions if quality is insufficient, supported by a local Python evaluation server.

dotnet/samples/Demos/QualityCheck · high confidence

Added two new sample files in the RAG concepts directory: \Bing\_RagWithTextSearch.cs\ demonstrates using the Bing search provider as a text search plugin to ground prompts, including variations with Handlebars templates and citation formatting; \WithPlugins.cs\ shows how to integrate custom plugins and in-memory vector stores into the RAG workflow, including examples of importing custom C\# plugins and using the \InMemoryVectorStore\ for local vector search.

dotnet/samples/Concepts/RAG · high confidence

Added a new set of C\# example projects in the \dotnet/samples/LearnResources/MicrosoftLearn\ directory to support Microsoft Learn documentation. These samples demonstrate core Semantic Kernel capabilities, including kernel creation with Azure OpenAI and OpenAI services, prompt engineering (structured, few-shot, and role-based), plugin development (native functions like \LightPlugin\ and \TimePlugin\), function calling with auto-execution, and prompt serialization using Handlebars templates.

dotnet/samples/LearnResources/MicrosoftLearn · high confidence

The Step02 sample now includes a comprehensive account opening scenario that guides users through filling out a new customer form, performing credit and fraud checks, and creating records in core, marketing, and CRM systems. The sample provides two process implementations: a flat pipeline in Step02a\_AccountOpening and a modular version in Step02b\_AccountOpening that uses nested subprocesses for verification and creation. Both versions include tests for successful interactions and failure paths (credit score rejection, fraud detection failure), demonstrating how to handle user input, emit events, and route them through various mock service steps.

dotnet/samples/GettingStartedWithProcesses/Step02 · high confidence

This change introduces the Step04 sample, which demonstrates how to orchestrate agent conversations using the Semantic Kernel process model. The sample includes a main orchestration test (Step04\_AgentOrchestration.cs) that sets up a KernelProcess with steps for user input, message rendering, and agent execution (including a manager agent and agent group chat). It also adds supporting components: event definitions (AgentOrchestrationEvents), a chat history provider abstraction (ChatHistoryProvider), kernel extensions for accessing agents and summarizing history (KernelExtensions), mock plugins for calendar, location, and weather data, and a JSON schema generator for type-based schema creation.

dotnet/samples/GettingStartedWithProcesses/Step04 · high confidence

This change introduces a new text search layer over vector stores, allowing users to perform natural-language searches on their data records. It adds the \VectorStoreTextSearch\<TRecord\>\ class, which bridges \IVectorSearchable\ and \IEmbeddingGenerator\ (or the obsolete \ITextEmbeddingGenerationService\) to execute text-based queries. The update includes extension methods for registering this service via \IServiceCollection\ and \IKernelBuilder\, as well as factory methods to create \KernelPlugin\ and \KernelFunction\ instances for direct AI agent integration. Additionally, it provides helper classes like \TextSearchResultPropertyReader\ to map record properties to search result attributes.

dotnet/src/SemanticKernel.Core/Data/TextSearch · high confidence

The TextSearchStore component in SemanticKernel.Core has been introduced to simplify Retrieval Augmented Generation (RAG) workflows by providing an opinionated schema for storing and retrieving text documents in a vector store. This new capability allows users to upsert documents with optional namespaces, source IDs, and links, and supports hybrid search (combining vector and full-text search) via configurable options. It also includes a source retrieval callback mechanism to fetch original text when it is not persisted in the database, enabling efficient citation and reference management.

dotnet/src/SemanticKernel.Core/Data/TextSearchStore · high confidence

Added a new console application sample in the TimePlugin demo that demonstrates how to use Semantic Kernel plugins with OpenAI's auto function calling feature. The sample configures an OpenAI chat completion service, registers a TimeInformationPlugin that retrieves the current UTC time, and enables automatic function selection via FunctionChoiceBehavior.Auto, allowing users to ask questions like 'What time is it?' to trigger the plugin.

dotnet/samples/Demos/TimePlugin · high confidence

Added a new internal TypeExtensions class providing helper methods for runtime type analysis. The TryGetGenericResultType method extracts the underlying type from common generic wrappers such as Task, Nullable, ValueTask, IEnumerable, IList, ICollection, and IDictionary, while GetFriendlyTypeName formats generic types into a readable string representation (e.g., List\<string\>).

dotnet/src/InternalUtilities/src/Type · high confidence

The VectorStoreRAG demo now supports ingestion of PDF files containing both text and images, using the chat completion service to convert images to text before indexing. The sample is configurable to use Azure OpenAI or OpenAI for chat and embeddings, and supports seven vector stores: Azure AI Search, Azure DocumentDB, Azure Cosmos DB NoSQL, InMemory, Qdrant, Redis, and Weaviate. It includes a console-based chat loop that uses a vector search plugin to ground LLM responses with retrieved content and citations.

dotnet/samples/Demos/VectorStoreRAG · high confidence

Added a new \WhiteboardProvider\ that implements \AIContextProvider\ to automatically maintain a summarized list of key information from a conversation. The provider uses an LLM to extract important details from recent messages and updates a 'whiteboard' of context, which is then injected into subsequent model invocations via \AIContext\. Users can configure the maximum number of whiteboard messages, custom prompts for context and empty states, and the maintenance prompt template used to update the whiteboard.

dotnet/src/SemanticKernel.Core/Memory/Whiteboard · high confidence

Added a new WorkflowBuilder class that enables the creation of KernelProcess instances by parsing YAML workflow definitions. This component supports defining process inputs (including CloudEvents and messages), processing workflow nodes (specifically dotnet and declarative agent steps), and handling orchestration logic, effectively allowing users to define and build workflows via YAML configuration in the local runtime.

dotnet/src/Experimental/Process.Core/Workflow · high confidence

The GettingStartedWithAgents/Orchestration directory now includes a comprehensive set of new sample tests demonstrating various agent orchestration strategies. These include Step01 and Step01a for concurrent execution (with optional structured output transforms), Step02 and Step02a for sequential pipelines (including cancellation handling), Step03 through Step03b for group chats (featuring round-robin, human-in-the-loop, and AI-managed flows), Step04 and Step04a for handoff-based triage systems (with structured input support), Step05 for magentic orchestration combining research and coding agents, and Step06 for mixing different agent types (ChatCompletion, Azure AI, OpenAI Assistant) within the same orchestration patterns. All samples utilize the InProcessRuntime and demonstrate features like streaming responses, orchestration monitoring, and custom group chat managers.

dotnet/samples/GettingStartedWithAgents/Orchestration · high confidence

The samples in dotnet/samples/Concepts/Agents have been refreshed with new demonstrations for Azure AI Agents, including file manipulation via the code interpreter and streaming interactions with plugins. Several ChatCompletionAgent samples have been added or updated to showcase advanced capabilities: contextual function selection using RAG to dynamically choose relevant tools, history reduction strategies (truncation and summarization) to manage conversation context, and serialization of AgentGroupChat sessions. Additional samples demonstrate integrating external memory providers like Mem0, implementing Retrieval Augmented Generation (RAG) with text search stores and citations, and configuring service selection for agents. Existing samples have also been updated to use the new OnIntermediateMessage callback and support streaming for function calls.

dotnet/samples/Concepts/Agents · high confidence

The auto-function invocation filter mechanism has been updated with a new API surface. A new \IAutoFunctionInvocationFilter\ interface allows filters to intercept automatic function calls via \OnAutoFunctionInvocationAsync\, and a new \AutoFunctionInvocationContext\ class provides the details for these events, including access to the kernel, chat history, execution settings, cancellation token, and sequence indices.

dotnet/src/SemanticKernel.Abstractions/Filters/AutoFunctionInvocation · high confidence

Semantic Kernel now includes built-in reducers to manage long chat histories and prevent token limit exceedances. Users can choose between \ChatHistorySummarizationReducer\, which compresses older messages into a summary using an AI service, and \ChatHistoryTruncationReducer\, which simply cuts off older messages. Both strategies are designed to preserve context integrity by ensuring function calls and results are never orphaned and by attempting to keep user messages aligned with assistant responses.

dotnet/src/SemanticKernel.Core/AI · high confidence

The integration test suite now includes dedicated configuration classes for various AI providers and services, including Azure AI, Azure AI Inference, Azure OpenAI, Bedrock Agent, Bing, Google, Mem0, Ollama, ONNX, OpenAI, and Tavily. These classes define the specific settings (such as endpoints, API keys, model IDs, and service IDs) required to configure the integration tests for each provider. Additionally, the previous generic OpenAI configuration class has been replaced by a new Azure Container App Session Pool configuration class, reflecting a shift in how session pool tests are configured.

dotnet/src/IntegrationTests/TestSettings · high confidence

The SemanticKernel abstractions now include new content classes to support advanced AI agent features and multimodal interactions. Users can now handle message annotations (including file, text, and URL citations) via \AnnotationContent\ and \AnnotationKind\, and represent agent actions with \ActionContent\ and \ReasoningContent\. Multimodal support is expanded with \AudioContent\ and \ImageContent\ (both inheriting from the new \BinaryContent\ base class), allowing for richer chat messages. Additionally, \FunctionCallContent\ and \FunctionResultContent\ provide structured handling for function calls, including a builder for streaming updates, while \ChatMessageContent\ gains a \Source\ property to track message origin and improved serialization polymorphism via \KernelContent\.

dotnet/src/SemanticKernel.Abstractions/Contents · high confidence

Added a new ASP.NET Core sample application that demonstrates how to host and run Semantic Kernel Processes using the Dapr runtime. The demo includes a controller to trigger process execution, a program configuration that registers Dapr actors for process support, and a multi-step process workflow (Kickoff, A, B, and C steps) that illustrates event routing, state persistence across cycles, and process termination.

dotnet/samples/Demos/ProcessWithDapr · high confidence

This change introduces the core abstractions for the Semantic Kernel function system, including the \KernelFunction\ abstract class, \KernelArguments\ for passing invocation data, and \FunctionResult\ for handling outcomes. It adds the \FromKernelServicesAttribute\, allowing function parameters to be automatically resolved from the \Kernel\'s service provider rather than just the arguments dictionary. Additionally, it establishes the \FullyQualifiedAIFunction\ base class to support standardized naming with plugin prefixes and integrates with \Microsoft.Extensions.AI\ for tool calling and content conversion.

dotnet/src/SemanticKernel.Abstractions/Functions · high confidence

Added new sample code demonstrating embedding generation via AWS Bedrock, Google AI (Vertex AI and standard), Hugging Face, Ollama, ONNX, and OpenAI, including support for custom embedding dimensions in Google AI. Introduced helper extension methods to simplify creating vector store collections from lists or search results, and added Docker-based test fixtures to automatically provision and manage local Postgres (pgvector), Qdrant, and Redis containers for vector store integration tests.

dotnet/samples/Concepts/Memory · high confidence

The OpenAI connector now exposes dedicated execution settings classes to configure specific OpenAI capabilities. \OpenAIAudioToTextExecutionSettings\ allows users to control transcription parameters such as language, prompt, response format, temperature, and timestamp granularities. \OpenAITextToAudioExecutionSettings\ provides settings for text-to-speech, including voice selection, audio format, and speed. \OpenAITextToImageExecutionSettings\ supports image generation with options for size, quality, style, and response format, including support for the \gpt-image-1\ model. Additionally, \OpenAIFileUploadExecutionSettings\ is introduced (though marked as deprecated in favor of direct SDK usage) to handle file upload purposes.

dotnet/src/Connectors/Connectors.OpenAI/Settings · high confidence

This change introduces three new extension classes in the Agents abstractions layer to simplify working with agent configurations and chat history. AgentDefinitionExtensions provides methods to automatically generate KernelArguments (including enabling automatic function calling when tools are defined) and create prompt templates from agent definitions. AgentToolDefinitionExtensions adds a generic GetOption method to safely retrieve and convert typed option values from tool definitions. ChatHistoryExtensions adds ToDescending and ToDescendingAsync methods to enumerate chat history in reverse chronological order, supporting the reducer pattern for processing conversation history.

dotnet/src/Agents/Abstractions/Extensions · high confidence

The MCPClient sample now includes a set of extension methods in the Extensions folder that bridge Model Context Protocol (MCP) protocol types with Semantic Kernel abstractions. Specifically, AuthorRoleExtensions and RoleExtensions handle bidirectional conversion between MCP roles and Semantic Kernel's AuthorRole, while ChatMessageContentExtensions and ContentBlockExtensions map between ChatMessageContent/KernelContent and MCP CreateMessageResult/ContentBlock types, supporting text, image, and audio modalities. PromptResultExtensions and SamplingMessageExtensions convert MCP prompt and sampling messages into Semantic Kernel ChatMessageContent collections, and ReadResourceResultExtensions transforms MCP resource contents (text, images, audio, or binary blobs) into ChatMessageContentItemCollections with appropriate metadata. These utilities enable the sample client to seamlessly consume MCP resources, prompts, and sampling responses within the Semantic Kernel chat completion workflow.

dotnet/samples/Demos/ModelContextProtocolClientServer/MCPClient/Extensions · high confidence

This change introduces a set of extension methods in the \dotnet/src/Agents/OpenAI/Extensions\ directory to facilitate the integration of OpenAI Assistants and Responses APIs with Semantic Kernel. \AgentDefinitionExtensions\ and \AssistantClientExtensions\ provide helpers to create OpenAI assistants and threads from agent definitions, supporting tools like code interpreter and file search, as well as Azure OpenAI connections. \KernelFunctionExtensions\ allows converting Semantic Kernel functions into OpenAI tool definitions. \ChatContentMessageExtensions\ and \OpenAIResponseExtensions\ handle the conversion between Semantic Kernel's \ChatMessageContent\ and OpenAI's \ThreadInitializationMessage\ and \ResponseItem\ types, including support for streaming updates and function calls. \OpenAIClientExtensions\ adds convenience methods for managing vector stores and assistant files.

dotnet/src/Agents/OpenAI/Extensions · high confidence

The Filtering samples directory now includes new concept examples demonstrating how to use Semantic Kernel filters for advanced scenarios. These include \AutoFunctionInvocationFiltering\ and \ChatClient\_AutoFunctionInvocationFiltering\ to show how to inspect, override, or terminate auto-invoked functions, and \AzureOpenAI\_DeploymentSwitch\ to demonstrate switching Azure OpenAI deployments based on specific function calls. Additional samples cover \FunctionInvocationFiltering\ for overriding results and handling exceptions in both streaming and non-streaming modes, \MaxTokensWithFilters\ for limiting token usage across multiple auto-function requests, \PIIDetection\ for integrating Microsoft Presidio to detect or anonymize PII in prompts, \PromptRenderFiltering\ for intercepting and modifying rendered prompts, \RetryWithFilters\ for implementing model fallbacks on errors (including streaming), and \TelemetryWithFilters\ for custom logging of function and prompt events.

dotnet/samples/Concepts/Filtering · high confidence

Added two new sample files, Step03a\_FoodPreparation.cs and Step03b\_FoodOrdering.cs, to the GettingStartedWithProcesses guide. Step03a demonstrates both stateless and stateful process execution for food items like fried fish and potato fries, including examples of persisting and restoring process state from local files. Step03b illustrates handling single-item food orders using a dedicated process for each food type.

dotnet/samples/GettingStartedWithProcesses/Step03 · high confidence

The FunctionCalling concept samples have been expanded with new demonstrations for key scenarios. A new Azure AI Inference sample shows how to use FunctionChoiceBehavior.Auto with the Azure AI Inference connector. A context-dependent advertising sample illustrates how to dynamically advertise specific functions to an AI model based on chat history state (e.g., game progress). Additionally, a shared state sample demonstrates how plugins can exchange data via a local state service during orchestrated function calls, and a return metadata sample shows techniques for providing function return type information to the model.

dotnet/samples/Concepts/FunctionCalling · high confidence

This change introduces a new \FunctionChoiceBehavior\ abstraction in the abstractions layer, replacing previous experimental function-calling implementations. It provides three distinct behaviors—\Auto\ (model decides whether to call functions), \Required\ (model must call functions, with logic to stop advertising them after the first request to prevent loops), and \None\ (functions are provided for the model to describe but not call). The implementation includes a \FunctionChoice\ enum, configuration classes (\FunctionChoiceBehaviorConfiguration\, \FunctionChoiceBehaviorConfigurationContext\), and options for controlling parallel calls, concurrent invocation, and strict schema adherence. This allows AI connectors to uniformly handle function selection and invocation strategies across different models.

dotnet/src/SemanticKernel.Abstractions/AI/FunctionChoiceBehaviors · high confidence

Adds a new sample demonstrating the Semantic Kernel Process Framework with gRPC communication. The \ProcessWithCloudEvents.Grpc\ project provides a gRPC server that orchestrates a document generation workflow (gathering info, generating docs via LLM, proofreading, and publishing) and exposes gRPC endpoints for external clients to interact with the process state. The \ProcessWithCloudEvents.Client\ project provides a React-based web UI that connects to this gRPC server to trigger document generation and review workflows.

dotnet/samples/Demos/ProcessWithCloudEvents, dotnet/samples/Demos/ProcessWithCloudEvents/ProcessWithCloudEvents.Client · high confidence

This change introduces a new set of internal helper classes in the Diagnostics namespace to support observability and input validation. ModelDiagnostics provides OpenTelemetry tracing for model interactions (text and chat completion, agent invocations) with sensitive data handling controlled by experimental switches. ActivityExtensions and LoggingExtensions standardize activity lifecycle management and structured logging for operations. KernelVerify adds validation for plugin and function names, while Throw and Verify provide consistent, performant argument checking and exception throwing across the library.

dotnet/src/InternalUtilities/src/Diagnostics · high confidence

Added new internal files to the planning utilities to support enhanced observability and flexible planning configuration. PlannerInstrumentation.cs introduces structured logging and metrics (via ActivitySource and Meter) for tracking plan creation and execution durations, including error handling and JSON serialization of plan details. PlannerOptions.cs and SemanticMemoryConfig.cs provide a new configuration model allowing users to exclude specific plugins or functions, override function lookup via a callback, and configure semantic memory filtering with thresholds and limits for relevant function discovery.

dotnet/src/InternalUtilities/planning · high confidence

This change introduces a suite of internal utilities in the Text namespace to support robust JSON handling and streaming data parsing. It adds specialized JsonConverters for booleans (including nullable variants) to correctly handle string-to-bool conversion in PromptExecutionSettings, and an ExceptionJsonConverter to allow serializing exceptions within chat history without throwing errors. Additionally, it provides a DataUri parser for RFC 2397 compliance, a centralized JsonOptionsCache for consistent serialization settings, and specialized parsers for Server-Sent Events (SseJsonParser, SseReader) and generic JSON streams (StreamJsonParser) to facilitate efficient processing of streaming connector responses.

dotnet/src/InternalUtilities/src/Text · high confidence

Added new extension methods in the planning utilities to support improved function discovery and context management. \ReadOnlyPluginCollectionPlannerExtensions\ now enables semantic search over available kernel functions using a registered memory provider, allowing planners to retrieve only relevant functions based on a query. It also provides methods to generate function manuals in both human-readable and JSON Schema formats. \KernelFunctionMetadataExtensions\ adds helpers to convert function metadata into JSON Schema views (including optional output schemas) and manual strings. \ChatHistoryExtensions\ introduces a new method to estimate token counts for chat history, supporting both a default character-based approximation and a custom token counter.

dotnet/src/InternalUtilities/planning/Extensions · high confidence

This change introduces a set of internal helper classes in the System utilities folder to support broader framework capabilities. AppContextSwitchHelper and EnvExtensions provide standardized ways to read configuration from app context switches and environment variables. TypeConverterFactory and InternalTypeConverter offer a Native-AOT-friendly mechanism for converting types to strings using hard-coded converters and attributes, avoiding reflection-heavy patterns. PathUtilities adds secure path resolution that safely handles symbolic links on .NET 6+ while rejecting them on older frameworks. NonNullCollection provides a generic list wrapper that enforces non-null items, and EmptyKeyedServiceProvider offers a minimal implementation of IKeyedServiceProvider. ValueTaskExtensions adds compatibility methods for .NET Standard 2.0.

dotnet/src/InternalUtilities/src/System · high confidence

The \SemanticKernel.Abstractions/Memory\ area now includes new foundational types for semantic memory and AI context management. This introduces \AIContext\ and \AIContextProvider\ (along with \AggregateAIContextProvider\) to allow providers to inject instructions and tools into AI model invocations. It also defines the core memory storage interfaces (\IMemoryStore\, \ISemanticTextMemory\) and data models (\MemoryRecord\, \MemoryRecordMetadata\, \DataEntryBase\, \MemoryQueryResult\), while moving the \NullMemory\ implementation to this abstractions layer to support scenarios where no persistent memory is required.

dotnet/src/SemanticKernel.Abstractions/Memory · high confidence

Added sample implementations for two optimization techniques: a few-shot prompt optimization filter that uses vector similarity to select the most relevant examples for a request, and a plugin selection filter that uses vector search to identify and share only the most relevant functions with the AI model. These samples demonstrate how to integrate these filters into the Semantic Kernel to reduce token consumption and improve performance in scenarios with large example sets or many available plugins.

dotnet/samples/Concepts/Optimization · high confidence

Added five new model classes in the Process.Abstractions namespace to support state persistence serialization for Semantic Kernel processes. These include KernelProcessStepStateMetadata as the base record with polymorphic JSON serialization, along with derived types for specific process components: KernelProcessStateMetadata for overall process state, KernelProcessMapStateMetadata for map step operations, and KernelProcessProxyStateMetadata for proxy steps including publish topics and event metadata. These models enable storing and restoring process execution state with versioning support.

dotnet/src/Experimental/Process.Abstractions/Models · high confidence

The \SemanticKernel.Abstractions\ library now includes \PromptExecutionSettings\ to manage AI request configurations such as service IDs, model IDs, and function choice behaviors, along with extension methods to convert these settings into \ChatOptions\. Additionally, a new \XmlPromptParser\ has been introduced to parse text prompts from XML format, featuring a bounded nesting depth (max 64 levels) to prevent stack exhaustion and optimize performance for non-XML inputs. The \PromptNode\ class, moved from the OpenAI connector to abstractions, supports this XML parsing by representing individual nodes with tags, content, attributes, and child nodes.

dotnet/src/SemanticKernel.Abstractions/AI · high confidence

A new prompt rendering filter pipeline has been introduced, allowing users to intercept and modify prompts before they are sent to the model. This includes the \IPromptRenderFilter\ interface for defining custom filtering logic and the \PromptRenderContext\ class, which exposes the kernel, function, arguments, execution settings, and a cancellable, modifiable \RenderedPrompt\. The context also supports streaming detection via an \IsStreaming\ flag and allows filters to short-circuit execution by setting a \Result\.

dotnet/src/SemanticKernel.Abstractions/Filters/Prompt · high confidence

The \dotnet/samples/Concepts/PromptTemplates\ directory now includes a comprehensive set of new sample files demonstrating how to use various prompt template formats with chat completion. These samples cover standard chat prompts, multi-turn chat loops using Handlebars, and the integration of audio and binary content via data URIs in chat prompts. Additionally, new examples illustrate the use of Handlebars and Liquid template engines for structured prompt rendering, the creation of functions from Prompty templates, and techniques for safely handling user input and function-generated content in chat contexts. These samples serve as practical references for implementing these specific template capabilities.

dotnet/samples/Concepts/PromptTemplates · high confidence

The MCP demo server now includes dedicated classes for defining resources and resource templates, simplifying how handlers are registered and invoked. ResourceDefinition and ResourceTemplateDefinition encapsulate the logic for matching URIs, extracting parameters via regular expressions, and invoking Semantic Kernel functions to serve content, with automatic fallback to a DI-registered Kernel instance. A new TextDataModel class is also added to support vector store integration for resource content.

dotnet/samples/Demos/ModelContextProtocolClientServer/MCPServer/Resources · high confidence

Added a suite of new Python sample scripts in the \concepts\ directory to demonstrate specific Semantic Kernel capabilities. These include structured output handling for Azure AI and OpenAI Assistant agents, audio recording and playback utilities, semantic caching using vector stores, and persistent chat history storage in Azure Cosmos DB. The samples also introduce complex and simple memory store patterns across various backends (e.g., Azure AI Search, Chroma, Pinecone), data model definitions for vector stores, and process orchestration examples featuring fan-in logic and state management.

semantic-kernel · high confidence

Added a new demo sample that connects to an MCP server (specifically the GitHub server via npx) to retrieve available tools, converts them into Semantic Kernel functions, and invokes them using both direct kernel prompting and a ChatCompletionAgent with automatic function calling.

dotnet/samples/Demos/ModelContextProtocolPlugin · high confidence

A new sample file (Step01\_Processes.cs) has been added to the GettingStartedWithProcesses/Step01 directory, illustrating how to build and run a multi-step process using the Semantic Kernel Process API. The sample defines a 'ChatBot' process comprising three steps: an introduction step, a user input step that handles a loop of questions and an exit command, and a response step that interacts with an OpenAI chat completion service. It demonstrates key process features such as event-driven transitions between steps, state management via a custom state class, and the ability to generate a Mermaid flowchart diagram of the process structure for visualization.

dotnet/samples/GettingStartedWithProcesses/Step01 · high confidence

The Step04 sample now includes three new process steps that implement a multi-agent workflow: a ManagerAgentStep that handles user interaction, delegates to a group of agents, and determines intent; an AgentGroupChatStep that manages collaborative agent responses and summarizes the group chat history; and a RenderMessageStep that formats and displays messages, errors, and completion status to the console. This change adds the specific orchestration logic and output rendering components for this sample scenario.

dotnet/samples/GettingStartedWithProcesses/Step04/Steps · high confidence

Added a new demo in dotnet/samples/Demos/ModelContextProtocolPluginAuth that shows how to connect to a protected Model Context Protocol (MCP) server using OAuth 2.0. The sample implements a custom browser-based authorization flow (opening a browser, listening on localhost:1179/callback, and exchanging the code for a token) to authenticate with an MCP server, then integrates the retrieved tools into a Semantic Kernel instance with automatic function calling.

dotnet/samples/Demos/ModelContextProtocolPluginAuth · high confidence

This change introduces a new set of internal utility classes for the samples directory to standardize how samples are tested and configured. It adds a \BaseTest\ class that simplifies kernel creation by automatically handling OpenAI and Azure OpenAI configuration, including support for Azure CLI authentication when API keys are missing, and allows redirecting console output to test logs. A centralized \TestConfiguration\ class is added to load settings for a wide range of providers (OpenAI, Azure, Ollama, Bing, etc.) from configuration sources. Supporting utilities include \ConfigurationNotFoundException\ for clear error reporting, \EmbeddedResource\ for loading text assets, \JsonResultTranslator\ for parsing JSON from agent responses, and various extensions (\EnumerableExtensions\, \ObjectExtensions\, \StringExtensions\) to aid sample code. The \XunitLogger\ has been refactored to support logging scopes and moved to this shared location, while \YourAppException\ and \RepoFiles\ are also consolidated here to provide common exception handling and repository file path resolution for samples.

dotnet/src/InternalUtilities/samples/InternalUtilities · high confidence

Added new sample files to the Concepts/Resources directory to support various AI capabilities. This includes an Azure Key Vault AI plugin definition (22-ai-plugin.json) and its corresponding OpenAPI specification (22-openapi.json) for interacting with secrets. It also introduces prompt template samples using Handlebars (65-prompt-override.handlebars, HandlebarsPrompt.yaml) and Liquid (LiquidPrompt.yaml) formats, alongside semantic-kernel format templates (GenerateStory.yaml, GenerateStoryHandlebars.yaml). Additionally, new text resources (30-system-prompt.txt, 30-user-context.txt, 30-user-prompt.txt, semantic-kernel-info.txt, travelinfo.txt, travel-destination-overview.txt) and a sales dataset (sales.csv) are provided for testing and demonstration purposes.

dotnet/samples/Concepts/Resources · high confidence

The MCP server sample now includes four new utility tools: DateTimeUtils provides a function to retrieve the current UTC time; WeatherUtils offers a mock weather lookup for specific cities; OrderProcessingUtils exposes placeholder functions for placing orders and executing refunds; and MailboxUtils demonstrates MCP sampling by summarizing unread emails (including text and image attachments) via a client-side sampling request.

dotnet/samples/Demos/ModelContextProtocolClientServer/MCPServer/Tools · high confidence

Added new sample files (AzureAIInference\_ChatCompletion.cs, AzureAIInference\_ChatCompletionStreaming.cs) demonstrating how to use the Azure AI Inference connector for chat completion and streaming. These samples show how to configure the service using Azure AI Foundry or GitHub Models endpoints, including examples for both direct service usage and kernel-based prompt invocation.

dotnet/samples/Concepts/ChatCompletion · high confidence

This update adds several new sample files in the Concepts/Plugins directory to demonstrate advanced Semantic Kernel capabilities. BuildingKernel.cs and ConfigureExecutionSettings.cs show how to use KernelBuilder to configure Azure OpenAI services and set model execution parameters like temperature and max tokens. CustomAIServiceSelector.cs demonstrates how to implement a custom IAIServiceSelector to route requests to specific models (e.g., GPT) among multiple registered services. Additionally, ApiManifestBasedPlugins.cs and CopilotAgentBasedPlugins.cs provide examples of loading plugins from API manifests and Copilot Agent manifests, including configuring authentication for Microsoft Graph and NASA APIs. Other new samples cover creating plugins from OpenAPI specs (GitHub, Jira, Klarna) and using the ConversationSummaryPlugin.

dotnet/samples/Concepts/Plugins · high confidence

Added new sample code demonstrating how to use the Semantic Kernel audio-to-text and image-to-text capabilities. The AudioToText sample shows how to configure the OpenAI Whisper model to transcribe audio files with optional language, prompt, and formatting settings. The ImageToText sample demonstrates using the HuggingFace connector to generate text descriptions from image files, including configuration of token limits.

dotnet/samples/Concepts/AudioToText, dotnet/samples/Concepts/ImageToText · high confidence

Added four new sample files in the DependencyInjection concept folder demonstrating how to integrate Semantic Kernel with .NET dependency injection containers. The samples cover basic and named HttpClient registration via IHttpClientFactory, configuring standard resilience policies (including retry logic for 401 errors) for HTTP calls, building the Kernel using IServiceCollection or direct ServiceProviders, and injecting the Kernel into application services via DI.

dotnet/samples/Concepts/DependencyInjection · high confidence

The Functions concept samples have been restructured to include new examples demonstrating how to pass arguments to kernel functions, access result metadata (including token usage), and handle strongly typed results. Additional samples illustrate advanced method function capabilities, such as chaining functions, accessing underlying method attributes, and defining functions via YAML configuration.

dotnet/samples/Concepts/Functions · high confidence

Added a new sample demonstrating semantic caching using prompt render and function invocation filters. The example shows how to cache LLM responses for similar prompts to reduce latency, supporting in-memory, Redis, and Azure Cosmos DB vector stores as the backing cache.

dotnet/samples/Concepts/Caching · high confidence

The GettingStartedWithProcesses samples now include reusable components to streamline process orchestration demonstrations. A new CommonEvents class defines standard event identifiers (UserInputReceived, UserInputComplete, AssistantResponseGenerated, Exit) used across samples. The ScriptedUserInputStep provides a configurable step that iterates through predefined user messages, emitting events for each input and signaling completion via the Exit event when the script ends. The DisplayAssistantMessageStep offers a ready-to-use step that outputs assistant responses in blue and emits the AssistantResponseGenerated event, allowing samples to focus on orchestration logic rather than boilerplate I/O and event handling.

dotnet/samples/GettingStartedWithProcesses/SharedSteps · high confidence

This location introduces the core abstractions for text search capabilities within Semantic Kernel. It adds the generic \ITextSearch\<TRecord\>\ interface, which enables type-safe filtering using LINQ expressions via the new \TextSearchOptions\<TRecord\>\ class, replacing the legacy non-generic \ITextSearch\ interface and \TextSearchFilter\ class (now marked obsolete). The change also includes supporting types such as \KernelSearchResults\<T\>\ for handling search outcomes, \TextSearchResult\ for normalized result data, and mapper interfaces (\ITextSearchResultMapper\, \ITextSearchStringMapper\) along with specific attributes (\TextSearchResultNameAttribute\, \TextSearchResultValueAttribute\, \TextSearchResultLinkAttribute\) to facilitate mapping record properties to search result fields.

dotnet/src/SemanticKernel.Abstractions/Data · high confidence

This location introduces a suite of new sample files demonstrating how to integrate external search capabilities into Semantic Kernel. The samples cover Bing, Google, and Tavily web search providers via the new \ITextSearch\ interface, showcasing features like function calling with grounding, citation inclusion, site-specific filtering, and enhanced LINQ-based filtering. Additionally, it includes a sample for using Bing and Google plugins for direct web queries and a custom Azure AI Search plugin example that demonstrates vector-based search integration with OpenAI embeddings.

dotnet/samples/Concepts/Search · high confidence

This change introduces two new helper classes in the Process.Core.Tools namespace to enhance process management and debugging. ProcessStepLoader enables the dynamic discovery of KernelProcessStep types from specified assembly paths, allowing for flexible step registration. ProcessVisualizationExtensions adds the ability to convert a ProcessBuilder or KernelProcess into a Mermaid flowchart string, providing a visual representation of the process structure, including nested sub-processes and step connections, which aids in understanding and debugging complex workflows.

dotnet/src/Experimental/Process.Core/Tools · high confidence

The GettingStartedWithProcesses sample now includes two new utility classes to support advanced process visualization and debugging. ProcessStateMetadataUtilities enables users to save and load KernelProcessStateMetadata to JSON files locally, facilitating state inspection and persistence. MermaidRenderer provides a method to generate PNG images from Mermaid code by leveraging Puppeteer-Sharp and a headless Chrome browser, allowing samples to produce visual flowcharts of process states.

dotnet/samples/GettingStartedWithProcesses/Utilities · high confidence

Developers can now register Ollama services (Text Generation, Chat Completion, Chat Client, and Embeddings) using standard .NET dependency injection patterns via new extension methods in \OllamaServiceCollectionExtensions\ and \OllamaKernelBuilderExtensions\. These additions allow Ollama integration to work seamlessly with Microsoft.Extensions.AI abstractions and Aspire, enabling easier configuration of model endpoints, custom HTTP clients, and service IDs through the standard \IServiceCollection\ and \IKernelBuilder\ APIs.

dotnet/src/Connectors/Connectors.Ollama/Extensions · high confidence

The .NET SDK has been reorganized to align with the Microsoft Agent Framework 1.0 release, introducing a new solution structure (SK-dotnet.slnx) and updated project references. This change includes the addition of new Agent-related projects (Agents.A2A, Agents.AzureAI, Agents.Bedrock, etc.), updated connectors (Connectors.Amazon, Connectors.AzureAIInference, Connectors.Google, etc.), and new sample applications for structured data plugins, ONNX CUDA chat, and quality checks. The SDK now targets .NET 10.0.303 and includes updated documentation reflecting the transition from Semantic Kernel to Microsoft Agent Framework.

dotnet · high confidence

The Step 3 sample now includes a complete set of food preparation processes (Fried Fish, Potato Fries, Fish Sandwich, Fish and Chips, and Single Order) that demonstrate stateful step management. These processes utilize new stateful steps such as CutFoodWithSharpeningStep (which tracks knife sharpness) and GatherIngredientsWithStockStep (which tracks ingredient inventory), allowing the sample to showcase how processes handle internal state, versioning, and complex event routing like fan-in/fan-out and conditional dispatching.

dotnet/samples/GettingStartedWithProcesses/Step03/Processes · high confidence

Semantic Kernel now allows developers to use any implementation of the standard Microsoft.Extensions.AI IChatClient interface directly within the Semantic Kernel pipeline. This change introduces a new adapter layer in the abstractions package that wraps IChatClient instances, enabling them to function as standard chat completion services. Users can leverage existing AI clients (such as those for Ollama or Azure OpenAI) without needing specific Semantic Kernel providers, while retaining access to kernel features like automatic function invocation, execution settings, and streaming responses through new extension methods and builder utilities.

dotnet/src/SemanticKernel.Abstractions/AI/ChatClient · high confidence

The Google AI embedding client now supports passing optional \dimensions\ and \taskType\ parameters to the Google API. Users can specify the number of dimensions for the generated embeddings via the \dimensions\ constructor argument or \EmbeddingGenerationOptions\, and configure the task type (e.g., for retrieval or classification) by including \task\_type\ or \tasktype\ in the \AdditionalProperties\ of \EmbeddingGenerationOptions\. This allows for more tailored embedding generation that aligns with specific Google AI model capabilities.

dotnet/src/Connectors/Connectors.Google/Core/GoogleAI · high confidence

The new AzureAIAgentFactory enables the system to handle declarative agent definitions for Azure AI Foundry agents. When an agent definition includes an existing ID, the factory retrieves the pre-provisioned agent from Azure; if no ID is provided, it creates a new agent instance. This allows users to seamlessly switch between instantiating new agents and attaching to existing ones using the same definition structure.

dotnet/src/Agents/AzureAI/Definition · high confidence

The Bedrock and OpenAI agent factories now support both creating new agents and retrieving existing ones by ID. When an AgentDefinition includes an ID, the Bedrock factory fetches the agent via the AWS Bedrock API, while the OpenAI factory retrieves the assistant via the OpenAI Assistants API; if no ID is provided, both factories create new agents and configure them with the specified model, instructions, and tools.

dotnet/src/Agents/Bedrock/Definition, dotnet/src/Agents/OpenAI/Definition · high confidence

The \Functions.OpenApi.Extensions\ library now provides new extension methods to import plugins directly from API manifest files (\ImportPluginFromApiManifestAsync\, \CreatePluginFromApiManifestAsync\) and Copilot Agent Plugin manifests (\ImportPluginFromCopilotAgentPluginAsync\, \CreatePluginFromCopilotAgentPluginAsync\). These methods allow users to configure plugin initialization with custom HTTP clients, user agents, and specific function execution parameters via new \ApiManifestPluginParameters\ and \CopilotAgentPluginParameters\ classes. Additionally, a new \DeclarativeAgentExtensions\ class enables creating chat completion agents from declarative agent manifests, automatically importing associated Copilot Agent Plugins defined in the manifest's actions. The library also includes an \OperationIdNormalizationOpenApiVisitor\ to ensure OpenAPI operation IDs are valid function names by replacing dots with underscores.

dotnet/src/Functions/Functions.OpenApi.Extensions · high confidence

The Bing web search connector, Microsoft To-Do task management connector, SQLite-based memory store, and OpenAI HTTP schema classes (including Azure deployment and completion request models) have been removed from the SemanticKernel.Connectors and SemanticKernel.AI.OpenAI.HttpSchema namespaces. Users relying on these specific integrations for search, task management, local persistence, or raw HTTP schema definitions will no longer have access to these components in this release.

dotnet/src/SemanticKernel.Connectors, dotnet/src/SemanticKernel/AI/OpenAI/HttpSchema · high confidence

The extension methods for ContextVariables (ToContextVariables, UpdateWithPlanEntry, ClearPlan, ToPlan) and SKContext (IsFunctionRegistered, ThrowIfSkillCollectionNotSet) have been removed from the Orchestration.Extensions namespace. This eliminates the previous convenience APIs for serializing/deserializing Plan objects into context variables and checking function registration within the execution context.

dotnet/src/SemanticKernel/Orchestration/Extensions · high confidence

The \FileIOSkill\, \HttpSkill\, \PlannerSkill\, \TextMemorySkill\, and \TextSkill\ classes, along with their associated \SemanticFunctionConstants\, have been removed from the \Microsoft.SemanticKernel.CoreSkills\ namespace. This change eliminates the built-in capabilities for file read/write operations, HTTP requests (GET/POST/PUT/DELETE), semantic planning, text memory recall, and string manipulation (trimming, case conversion) from this package, requiring users to implement these functionalities elsewhere or use alternative connectors.

dotnet/src/SemanticKernel/CoreSkills · high confidence

The \Exception.cs\ and \Verify.cs\ files in the \Microsoft.SemanticKernel.Diagnostics\ namespace have been removed. This eliminates the custom generic exception base class and the internal static helper methods used for validating skill names, function names, parameter names, and parameter uniqueness, simplifying the diagnostics layer by removing these specific implementation details.

dotnet/src/SemanticKernel/Diagnostics · high confidence

This change removes a significant number of deprecated .NET sample projects and their associated configuration files from the repository. Specifically, the \samples/apps/.eslingrc.js\ and \samples/apps/prettier.config.js\ files are deleted, along with the entire \samples/dotnet/api-azure-function\ directory (including its Azure Function implementation, models, and configuration). Additionally, the \samples/dotnet/graph-api-skills\ sample and the \samples/dotnet/kernel-extension-load-prompts-from-cloud\ sample are removed, as are several example files within \samples/dotnet/kernel-syntax-examples\ (such as \Example01\_NativeFunctions.cs\ through \Example05\_CombineLLMPromptsAndNativeCode.cs\) and the \samples/dotnet/KernelBuilder\ sample. This cleanup eliminates legacy code paths and reduces maintenance overhead for outdated examples.

samples · high confidence

The internal \Json\ helper class and the \StringExtensions\ class containing the \EqualsIgnoreCase\ method have been removed from the \Microsoft.SemanticKernel.Text\ namespace. This cleanup eliminates local wrappers around \System.Text.Json\ serialization and custom string comparison logic, likely to reduce code duplication or rely on standard library equivalents elsewhere in the codebase.

dotnet/src/SemanticKernel/Text · high confidence

The \AIException\ class, \CompleteRequestSettings\ class, and \ITextCompletionClient\ interface have been removed from the \Microsoft.SemanticKernel.AI\ namespace. This eliminates the previous exception hierarchy with specific error codes (such as \Throttling\ or \ModelNotAvailable\) and the dedicated settings object for completion parameters (temperature, top\_p, max\_tokens, etc.), along with the interface used to invoke text completions. Users relying on these specific types for error handling or configuring completion requests will need to adopt the updated API structures.

dotnet/src/SemanticKernel/AI · high confidence

The \dotnet/src/SemanticKernel/AI/Embeddings\ directory has been cleaned up by removing several legacy types that are no longer part of the public API. Specifically, the generic \Embedding\<TEmbedding\>\ struct, the \EmbeddingReadOnlySpan\<TEmbedding\>\ and \EmbeddingSpan\<TEmbedding\>\ ref structs, and the \IEmbeddingGenerator\, \IEmbeddingIndex\, and \SupportedTypes\ interfaces/classes have been deleted. This change removes the previous generic vector representation and associated index/generator abstractions from this location, simplifying the embedding API surface.

dotnet/src/SemanticKernel/AI/Embeddings · high confidence

The \KernelConfig\, \IKernel\, \Kernel\, \KernelBuilder\, \KernelException\, and \IRetryMechanism\ classes have been removed from the \dotnet/src/SemanticKernel\ directory. This change eliminates the previous configuration model (including methods like \AddAzureOpenAICompletionBackend\ and \AddOpenAICompletionBackend\), the \KernelBuilder\ pattern for constructing kernel instances, and the \RunAsync\ pipeline execution API. Users must migrate to the updated kernel construction and function invocation mechanisms provided by the new core architecture.

dotnet/src/SemanticKernel · high confidence

The \ImportSemanticSkillFromDirectory\, \InlineFunctionsDefinitionExtension\, and \MemoryConfiguration\ classes have been removed from the \KernelExtensions\ namespace. This eliminates the ability to import semantic skills directly from filesystem directories, define semantic functions via inline string templates with automatic registration, and configure semantic memory using the legacy \UseMemory\ extension methods that relied on the old \BackendConfig\ and specific embedding backend types (Azure OpenAI, OpenAI). Users must now use the updated memory and function registration APIs provided in other parts of the library.

dotnet/src/SemanticKernel/KernelExtensions · high confidence

The specific service implementations for OpenAI and Azure OpenAI text completion and embeddings have been removed from the codebase. This includes the deletion of configuration classes (OpenAIConfig, AzureOpenAIConfig) and client classes (OpenAITextCompletion, OpenAITextEmbeddings, AzureTextCompletion, AzureTextEmbeddings) located in the dotnet/src/SemanticKernel/AI/OpenAI/Services directory. Users relying on these direct service instantiations will need to migrate to the updated connector abstractions or newer API surfaces provided by the Semantic Kernel.

dotnet/src/SemanticKernel/AI/OpenAI/Services · high confidence

The integration test suite in the \dotnet/src/IntegrationTest\ directory has been cleaned up by removing obsolete test files and their supporting configuration. Specifically, \OpenAICompletionTests.cs\ and \WebSkillTests.cs\ were deleted, along with the \testsettings.json\ configuration file, the \README.md\ setup guide, and helper classes like \RedirectOutput.cs\ and \AzureOpenAIConfiguration.cs\. This removes the ability to run integration tests against OpenAI completion backends and Bing web search skills using the previous configuration structure.

dotnet/src/IntegrationTest · high confidence

The \IPromptTemplateEngine\ interface and the \PromptTemplateEngine\ class have been removed from the \dotnet/src/SemanticKernel/TemplateEngine\ directory. This cleanup eliminates the legacy template rendering logic that previously handled block extraction, variable rendering, and code execution via \SKContext\. Users relying on this specific engine implementation will need to migrate to the current template processing mechanisms provided by the Semantic Kernel.

dotnet/src/SemanticKernel/TemplateEngine · high confidence

The \SemanticFunctions\ namespace and its core components—\IPromptTemplate\, \PromptTemplate\, \PromptTemplateConfig\, and \SemanticFunctionConfig\—have been removed from the SemanticKernel. This eliminates the previous mechanism for defining and rendering prompt templates via configuration objects and the \IPromptTemplateEngine\, effectively cleaning up the template engine interface and requiring users to adopt the updated function and plugin abstractions.

dotnet/src/SemanticKernel/SemanticFunctions · high confidence

The \SkillDefinition\ folder has been completely removed, deleting the legacy \SkillCollection\, \ISkillCollection\, \IReadOnlySkillCollection\, \ReadOnlySkillCollection\, \FunctionView\, \FunctionsView\, \ParameterView\, and all associated attributes (\SKFunctionAttribute\, \SKFunctionInputAttribute\, etc.). This eliminates the old skill-based function registration and introspection APIs, requiring users to migrate to the updated plugin and function management system.

dotnet/src/SemanticKernel/SkillDefinition · high confidence

The \Block\, \CodeBlock\, and \VarBlock\ classes within the \dotnet/src/SemanticKernel/TemplateEngine/Blocks\ directory have been removed. This deletion eliminates the internal implementation for parsing and rendering template blocks (such as variable substitution and code execution) that relied on \SKContext\, \ContextVariables\, and \ILogger\. Users relying on this specific template engine subsystem will no longer have access to these components.

dotnet/src/SemanticKernel/TemplateEngine/Blocks · high confidence

The \dotnet/src/SemanticKernel/AI/Embeddings/VectorOperations\ directory has been completely removed. This deletes the legacy implementation files for vector math operations, including \CosineSimilarityOperation\, \DivideOperation\, \DotProductOperation\, \EuclideanLengthOperation\, \MultiplyOperation\, \NormalizeOperation\, and \SpanExtensions\. Users relying on these specific internal extension methods for vector manipulation will no longer have access to them in this location.

dotnet/src/SemanticKernel/AI/Embeddings/VectorOperations · high confidence

The \FunctionFlowRunner\, \PlanRunner\, \Plan\, \PlanningException\, and \SKContextExtensions\ classes in the \dotnet/src/SemanticKernel/Planning\ directory have been removed. This eliminates support for executing plans defined in XML format and the associated serialization logic, streamlining the planning API by discarding the older XML-centric execution model.

dotnet/src/SemanticKernel/Planning · high confidence

The \ContextVariables\, \SKContext\, \ISKFunction\, \SKFunction\, and \SKFunctionExtensions\ classes in the \Microsoft.SemanticKernel.Orchestration\ namespace have been removed. This eliminates the previous context-passing mechanism and function invocation model, requiring users to adopt the updated orchestration APIs provided in other parts of the library.

dotnet/src/SemanticKernel/Orchestration · high confidence

The \SemanticTextPartitioner\ class and the \FunctionExtensions\ helper for aggregating partitioned results have been removed from the SemanticKernel library. This eliminates the previous mechanism for splitting text into lines or paragraphs based on token counts and the associated extension method for invoking semantic functions on those partitions, requiring users to adopt alternative text processing or function orchestration strategies.

dotnet/src/SemanticKernel/SemanticFunctions/Partitioning · high confidence

The Authenticated API Webapp React sample application has been deleted. This removal eliminates the React-based frontend that previously allowed users to authenticate via Microsoft Account, configure OpenAI or Azure OpenAI keys, and interact with Microsoft Graph services (Outlook, OneDrive, ToDo) through Semantic Kernel skills. Users can no longer run this specific learning sample to demonstrate authentication patterns and API integration.

samples/apps/auth-api-webapp-react · high confidence

The Book Creator sample application for React has been removed from the repository. This change deletes the entire \samples/apps/book-creator-webapp-react\ directory, including the React source code, configuration files, and documentation. Users can no longer run this specific educational sample to explore Semantic Kernel concepts via a web interface.

samples/apps/book-creator-webapp-react · high confidence

The Chat Summary React sample application has been deleted from the repository. This change removes the entire \samples/apps/chat-summary-webapp-react\ directory, including the React frontend components, configuration files, and documentation. Users will no longer have access to this specific learning sample that demonstrated semantic function usage for conversation summarization, action item extraction, and topic identification via an Azure Function backend.

samples/apps/chat-summary-webapp-react · high confidence

The DocumentPlugin has been hardened to prevent unauthorized file access by defaulting to an empty list of allowed directories. Users must now explicitly configure the AllowedDirectories property with trusted paths before the plugin can read or write any files; any path outside these allowed directories will be rejected. Additionally, the plugin now canonicalizes file paths and expands environment variables before validation to prevent directory traversal attacks, and it blocks unsupported UNC or extended-length paths.

dotnet/src/Plugins/Plugins.Document · high confidence

The gRPC plugin integration now includes built-in security controls to prevent Server-Side Request Forgery (SSRF) attacks. Users can configure \GrpcFunctionExecutionParameters\ to restrict which server addresses and URI schemes are allowed when invoking gRPC functions. By default, only HTTPS schemes are permitted, and developers can explicitly define allowed base addresses or override the target address, ensuring that function calls remain within trusted boundaries.

dotnet/src/Functions/Functions.Grpc/Extensions · high confidence

The OpenAPI plugin now enforces strict server URL validation by default to prevent Server-Side Request Forgery (SSRF) attacks. Requests to non-HTTPS schemes or private IP ranges (such as localhost, cloud metadata endpoints, and RFC1918 networks) are rejected unless explicitly permitted via the new \AllowedBaseUrls\ allowlist or by setting \AllowPrivateNetworkAccess\ to true. This protection applies to URLs derived from the OpenAPI document's \servers\[\].url\ field and any server-variable substitutions, ensuring that untrusted specifications cannot be used to access internal or local resources.

dotnet/src/Functions/Functions.OpenApi · high confidence

The internal implementation of the OpenAI Assistant and Response agents has been restructured to improve testability and code organization. New factory classes—AssistantMessageFactory, AssistantRunOptionsFactory, AssistantToolResourcesFactory, and ResponseCreationOptionsFactory—now handle the creation of API-specific options and message content, separating concerns from the main agent logic. Additionally, dedicated thread-action classes (AssistantThreadActions and ResponseThreadActions) manage the core invocation, streaming, and polling cycles for their respective agent types. This change isolates the mechanics of interacting with the OpenAI Assistants and Responses APIs, making the internal components easier to maintain and test without altering the public agent interfaces.

dotnet/src/Agents/OpenAI/Internal · high confidence

The Azure OpenAI connector extension methods in \AzureOpenAIKernelBuilderExtensions\ and \AzureOpenAIServiceCollectionExtensions\ have been updated to support authentication via \TokenCredential\ (e.g., \DefaultAzureCredential\) in addition to API keys, allowing users to leverage Azure managed identities or other credential providers. These methods also now accept an optional \apiVersion\ parameter to specify the Azure OpenAI API version, and an optional \httpClient\ to allow custom HTTP client configuration. This change enables more flexible and secure authentication patterns for Azure OpenAI services within the Semantic Kernel.

dotnet/src/Connectors/Connectors.AzureOpenAI/Extensions, dotnet/src/Connectors/Connectors.AzureOpenAI/Services · high confidence

The core plugins in this location have been reorganized and hardened: \TimeSkill\ is now \TimePlugin\ and accepts an injectable \TimeProvider\ for deterministic testing, while \ConversationSummaryPlugin\ has been refactored to use \KernelFunctionFactory\ with updated prompts that improve action item extraction and language detection. Security defaults have been strengthened across \FileIOPlugin\ (now deny-by-default with explicit \AllowedFolders\), \HttpPlugin\ (deny-by-default with \AllowedDomains\, private network blocking, and disabled redirects), and \SessionsPythonPlugin\ (new code interpreter plugin with strict \AllowedDomains\, \AllowedUploadDirectories\, and \AllowedDownloadDirectories\ controls). Additionally, prompt definitions have moved to \PromptFunctionConstants\ and the \KernelFunction\ attribute replaces the legacy \SKFunction\ marker.

dotnet/src/Plugins/Plugins.Core · high confidence

The Step00 sample in the GettingStartedWithProcesses directory has been updated to provide a working example of the simplest KernelProcess implementation. The previous version contained errors; the corrected code now demonstrates creating a process with four sequential steps (StartStep, DoSomeWorkStep, DoMoreWorkStep, LastStep), wiring them via function results, and starting the process with an initial event.

dotnet/samples/GettingStartedWithProcesses/Step00 · high confidence

The StepwisePlannerMigration demo application now provides a side-by-side comparison of the legacy FunctionCallingStepwisePlanner and the new recommended Auto Function Calling approach. The sample includes controllers for both methods, demonstrating how to generate plans, execute new plans, and replay existing plans using the new FunctionChoiceBehavior.Auto() settings, which the documentation notes are more reliable and token-efficient.

dotnet/samples/Demos/StepwisePlannerMigration · high confidence

The embedding generation interfaces (\IEmbeddingGenerationService\, \ITextEmbeddingGenerationService\) and their extension methods in \Microsoft.SemanticKernel.Embeddings\ are now obsolete and marked with the \SKEXP0001\ experimental attribute. Users are directed to migrate to \Microsoft.Extensions.AI.IEmbeddingGenerator\<string, Embedding\<float\>\>\. The diff provides adapter classes (\EmbeddingGenerationServiceEmbeddingGenerator\, \EmbeddingGeneratorEmbeddingGenerationService\) and extension methods (\AsEmbeddingGenerator\, \AsEmbeddingGenerationService\, \AsTextEmbeddingGenerationService\) to facilitate bidirectional conversion between the legacy SemanticKernel services and the new Microsoft.Extensions.AI interfaces, ensuring compatibility during the transition.

dotnet/src/SemanticKernel.Abstractions/AI/Embeddings · high confidence

The OpenAI connector now marks the \OpenAIFilePurpose\ and \OpenAIFileReference\ model classes as obsolete, advising users to switch to the native OpenAI or Azure OpenAI SDKs for file operations as these classes will be removed in a future version. Additionally, internal utilities have been added to support the connector's underlying pipeline, including a new \ClientResultExceptionExtensions\ class that converts SDK-specific exceptions into standard \HttpOperationException\ instances, and a \GenericActionPipelinePolicy\ for processing pipeline messages.

dotnet/src/Connectors/Connectors.OpenAI/Models, dotnet/src/InternalUtilities/openai · high confidence

The OpenAPI plugin now supports a broader range of REST API parameter styles and data types. New serializers handle Form, Simple, SpaceDelimited, and PipeDelimited styles, including proper URL encoding and array expansion (e.g., id=1&id=2 vs id=1,2,3). Additionally, a new type converter ensures arguments are correctly converted to JSON nodes for string, integer, boolean, and number types, and validates arguments against JSON schemas when the type is unspecified.

dotnet/src/Functions/Functions.OpenApi/Serialization · high confidence

The internal model classes for the Google Gemini connector have been restructured to support advanced capabilities. GeminiContent and GeminiPart now handle multi-part messages including text, inline/file-based images and videos, and function calls/responses. GeminiRequest supports system instructions, labels, and cached content, while also fixing single-turn request handling to prevent API errors. GeminiResponse includes updated usage metadata for cached content and thought tokens, and GeminiTool now uses OpenAPI 3.03-compliant function declarations. These changes enable richer multimodal interactions, better function calling support, and improved reasoning context management.

dotnet/src/Connectors/Connectors.Google/Core/Gemini/Models · high confidence

The Getting Started sample has been completely rewritten to demonstrate the new ChatClient-based API for Semantic Kernel. The new step-by-step guide (Steps 1–9) shows how to create a Kernel using \AddOpenAIChatClient\, invoke prompts, load plugins (including YAML and OpenAPI definitions), use dependency injection, and implement filters for responsible AI and observability. The sample also introduces function pipelining and graph capabilities, providing a comprehensive, up-to-date reference for building applications with the latest Semantic Kernel features.

dotnet/samples/GettingStarted · high confidence

The Hugging Face connector now provides extension methods on IKernelBuilder and IServiceCollection to register text generation, chat completion, and embedding generator services, with the endpoint parameter made optional for chat completion. The HuggingFacePromptExecutionSettings class now includes JsonNumberHandling and JsonConverter attributes to correctly handle numeric and boolean values during serialization, and the embedding service registration has been updated to use the IEmbeddingGenerator interface while the older ITextEmbeddingGenerationService methods are marked obsolete.

dotnet/src/Connectors/Connectors.HuggingFace · high confidence

The OpenAI connector now uses a new helper class to build JSON schema response formats, leveraging Microsoft.Extensions.AI for schema generation instead of the previous internal mapper. This change ensures that structured outputs are generated with stricter schema validation (disallowing additional properties and requiring all properties) and automatically handles nullable types by extracting their underlying types for schema creation.

dotnet/src/Connectors/Connectors.OpenAI/Helpers · high confidence

The integration test project has been reorganized, introducing a new \BaseIntegrationTest\ class that configures HTTP resilience (retry, circuit breaker, and timeout policies) for kernel builders. A new \RedirectOutput\ class replaces the previous \XunitLogger\ to handle test output and logging, while \TestHelpers\ provides utilities for importing sample plugins. The suite now includes a comprehensive \testsettings.json\ defining configurations for OpenAI, Azure OpenAI, HuggingFace, MistralAI, and various vector stores, alongside a detailed \README.md\ guiding users on setup via Secret Manager, configuration files, or environment variables.

dotnet/src/IntegrationTests · high confidence

The TextGeneration location now exposes the new ITextGenerationService interface, replacing the previous ITextCompletion abstraction, to define how text generation services interact with the Kernel. This change introduces extension methods that automatically parse standardized prompts (including chat history formats) and route them to the appropriate underlying service, ensuring that prompts are handled correctly whether they target a chat completion or a raw text generation endpoint.

dotnet/src/SemanticKernel.Abstractions/AI/TextGeneration · high confidence

The event-based observability classes in the Microsoft.SemanticKernel namespace (including KernelEventArgs, CancelKernelEventArgs, FunctionInvokedEventArgs, FunctionInvokingEventArgs, PromptRenderedEventArgs, and PromptRenderingEventArgs) are now marked as obsolete. Users relying on these events for function invocation or prompt rendering hooks should migrate to the new filter system, with migration examples provided in the repository samples.

dotnet/src/SemanticKernel.Abstractions/Events · high confidence

The \dotnet/src/SemanticKernel/Memory\ directory has been cleaned up by removing the legacy memory interfaces and storage implementations. Specifically, \IMemoryStore\, \ISemanticTextMemory\, \MemoryRecord\, \SemanticTextMemory\, and the underlying storage primitives (\DataEntry\, \IDataStore\, \VolatileDataStore\, \VolatileMemoryStore\) have been deleted. This change simplifies the memory architecture by removing the generic, unmanaged-typed embedding store abstractions and the volatile in-memory storage provider that previously lived in this location, likely as part of a broader move to consolidate vector stores into connectors or replace them with newer abstractions.

dotnet/src/SemanticKernel/Memory · high confidence

The Microsoft Graph plugins (Email, Calendar, Cloud Drive, Task List, and Organization Hierarchy) have been relocated from the \SemanticKernel.Connectors\ namespace to \SemanticKernel.Plugins.MsGraph\. As part of this move, the CloudDrivePlugin now enforces a deny-by-default security model: file read, write, and share-link operations are blocked unless the user explicitly configures allowed paths via properties like \AllowedUploadDirectories\ and \AllowedReadPaths\. Additionally, the plugins are marked as experimental via the \SKEXP0050\ attribute, and internal connectors have been updated to use modern C\# patterns and safer async practices.

dotnet/src/Plugins/Plugins.MsGraph · high confidence

A new HttpOperationException class has been introduced to represent errors specific to HTTP operations, allowing developers to access the HTTP status code and response content directly via StatusCode and ResponseContent properties. The exception also includes RequestMethod, RequestUri, and RequestPayload properties, but these are marked as obsolete and will be removed in a future version; users should instead rely on the Exception.Data dictionary with keys 'Name', 'Url', and 'Data' respectively to access request metadata in a manner consistent with OpenTelemetry standards.

dotnet/src/SemanticKernel.Abstractions/Http · high confidence

The OpenAPI plugin now uses a new \OpenApiDocumentParser\ that automatically downgrades OpenAPI 3.1 documents to the supported 3.0.1 specification to ensure compatibility with the underlying parsing library. Additionally, the parser exposes \OpenApiDocumentParserOptions\, allowing users to ignore non-compliant document errors and to filter which operations are imported via a configurable \OperationSelectionPredicate\.

dotnet/src/Functions/Functions.OpenApi/OpenApi · high confidence

The OpenAPI plugin now introduces a comprehensive set of model classes in the \Functions.OpenApi/Model\ directory to represent REST API specifications and operations. These include \RestApiOperation\ for defining API endpoints, \RestApiParameter\ and \RestApiPayload\ for handling inputs and request bodies, \RestApiSecurityRequirement\ and \RestApiSecurityScheme\ for authentication, and supporting types like \RestApiServer\ and \RestApiOAuthFlows\. This refactoring replaces previous internal structures with a more explicit and robust object model, enabling better handling of server variables, security schemes, and operation metadata within the plugin.

dotnet/src/Functions/Functions.OpenApi/Model · high confidence

The connector now exposes a new \ToolCallBehavior\ abstraction in \ToolCallBehavior.cs\ to manage how the OpenAI model requests and executes functions. This introduces factory methods like \EnableKernelFunctions\ and \RequireFunction\ to configure tool availability and auto-invocation, replacing previous ad-hoc configurations. It also deprecates the \ToolCallResultSerializerOptions\ property in favor of the global \Kernel.SerializerOptions\.

dotnet/src/Connectors/Connectors.OpenAI · high confidence

The gRPC plugin model layer now includes dedicated classes to describe gRPC operations and their data contracts. A new \GrpcOperation\ class exposes service and operation names, request/response type metadata, and an optional address, while also providing a factory method to create kernel parameter metadata for the request payload. A new \GrpcOperationDataContractType\ class represents a data contract with a name and a list of fields, and a new \GrpcOperationDataContractTypeFiled\ class (renamed from the previous \BackendConfig\) stores individual field details including name, number, and type name. These changes restructure the internal model to better support gRPC function discovery and invocation within the Semantic Kernel plugins.

dotnet/src/Functions/Functions.Grpc/Model · high confidence

The internal utilities for AI connectors now include a new FunctionCallsProcessor component that manages the execution of AI-generated function calls. This processor introduces safeguards against runaway execution by limiting both the total number of auto-invocations per user request and the number of concurrent in-flight invocations. It also supports concurrent invocation of multiple functions when enabled, and integrates with the auto function invocation filter to allow custom logic to intercept or terminate the process. Enhanced logging has been added to track function choice behavior, invocation contexts, and termination events for better observability.

dotnet/src/InternalUtilities/connectors/AI · high confidence

Added two internal helper classes to the Agents core: ChatMessageForPrompt, which provides a method to format chat messages for prompts by serializing them with optional name-only mode, and CoreKernelArgumentsExtensions, which introduces a MergeArguments method to combine primary and override KernelArguments with precedence given to the override settings and parameters.

dotnet/src/Agents/Core/Internal · high confidence

The prompt template system has been refactored to use a new \IPromptTemplate\ interface and \IPromptTemplateFactory\ for creating and rendering templates, replacing the previous implementation. \PromptTemplateConfig\ now serves as the central configuration class, managing input and output variables (defined in new \InputVariable\ and \OutputVariable\ classes), execution settings, and template formats. Input variables now support JSON Schema definitions and a new \AllowDangerouslySetContent\ property to control prompt injection risks. The \TemplateOptions\ class provides configuration for template formats and parsers, supporting multiple templating languages like Handlebars and Prompty.

dotnet/src/SemanticKernel.Abstractions/PromptTemplate · high confidence

The prompt rendering system has been restructured around a new factory pattern, introducing \AggregatorPromptTemplateFactory\ to chain multiple factories, \EchoPromptTemplateFactory\ for passthrough rendering, and \KernelPromptTemplateFactory\ as the default handler for Semantic Kernel templates. The core \KernelPromptTemplate\ now enforces stricter security by default: it disables potentially dangerous content injection via the \AllowDangerouslySetContent\ flag (defaulting to false) and automatically HTML-encodes variable outputs unless explicitly marked as safe, protecting against prompt injection. Additionally, the template engine now automatically detects and registers any variables referenced in the prompt text or code blocks as input variables, simplifying configuration.

dotnet/src/SemanticKernel.Core/PromptTemplate · high confidence

The dedicated \OllamaChatCompletionService\ and \OllamaTextEmbeddingGenerationService\ classes are now marked as obsolete. Users should migrate to using the \AsChatCompletionService()\ and \AsEmbeddingGenerationService()\ extension methods on \OllamaApiClient\ instead. The \OllamaTextGenerationService\ remains available and continues to support Ollama-specific settings such as \Think\, \NumPredict\, \Temperature\, \TopP\, \TopK\, and \Stop\ sequences.

dotnet/src/Connectors/Connectors.Ollama/Services · high confidence

The Ollama connector's execution settings now include a new \Think\ property, allowing users to explicitly enable or disable the reasoning output stream for models that support it (such as deepseek-r1, qwen3, and phi4-reasoning). Additionally, the \FromExecutionSettings\ method has been updated to correctly restore the \FunctionChoiceBehavior\ state after serialization, and the \Clone\ method now preserves this behavior along with the new \Think\ setting, ensuring that function choice configurations are not lost when settings are copied or converted.

dotnet/src/Connectors/Connectors.Ollama/Settings · high confidence

The OpenAI connector now registers services using the standard Microsoft.Extensions.AI abstractions (IChatClient, IEmbeddingGenerator) via new extension methods on IKernelBuilder and IServiceCollection, replacing the previous connector-specific service registrations. This change introduces AddOpenAIChatClient and AddOpenAIEmbeddingGenerator for dependency injection, deprecates older methods like AddOpenAITextEmbeddingGeneration, and adds a ChatHistory extension (AddStreamingMessageAsync) to correctly handle streaming responses and tool calls. Additionally, plugin collection extensions now support resolving functions from OpenAI tool calls, and custom endpoint configuration properly respects HttpClient.BaseAddress.

dotnet/src/Connectors/Connectors.OpenAI/Extensions · high confidence

The OpenAI connector has been rewritten to target the OpenAI .NET SDK v2, introducing support for new model capabilities and modernizing the underlying implementation. Users can now generate images using the new gpt-image-1 model (migrating from deprecated DALL-E models), transcribe audio to text with configurable timestamp granularities, and synthesize speech from text with various voice and format options. The chat completion engine now supports parallel function calls, strict JSON schema adherence for tool definitions, and structured outputs. Additionally, the connector includes a new JSON converter for serializing chat tool calls and handles empty content in assistant messages by using empty strings instead of null values.

dotnet/src/Connectors/Connectors.OpenAI/Core · high confidence

The service layer in SemanticKernel.Abstractions has been updated to improve how AI services are selected and accessed. The IAIServiceSelector interface now uses a TrySelectAIService pattern, allowing callers to safely attempt service resolution without exceptions, and a new IChatClientSelector interface has been added to support selecting IChatClient instances. The OrderedAIServiceSelector implementation has been refined to prioritize service selection by service ID, then model ID, and finally default settings, ensuring more predictable behavior when multiple services are registered. Additionally, new extension methods on IAIService (GetModelId, GetEndpoint, GetApiVersion) provide convenient access to common service attributes, and AIServiceExtensions now exposes SelectAIService methods that integrate with KernelFunction and KernelArguments for context-aware service resolution.

dotnet/src/SemanticKernel.Abstractions/Services · high confidence

The \AzureOpenAIClientAbstract\ and \OpenAIClientAbstract\ classes in the \dotnet/src/SemanticKernel/AI/OpenAI/Clients\ directory have been removed. This deletion eliminates the previous implementation of the Azure and base OpenAI client logic, including deployment caching, HTTP request execution, and error handling, indicating a structural shift in how the Semantic Kernel interacts with OpenAI services.

dotnet/src/SemanticKernel/AI/OpenAI/Clients · high confidence

The repository documentation has been significantly updated: the README now highlights Microsoft Agent Framework as the successor, updates system requirements to .NET 10 and Python 3.10+, and provides new quickstart code samples for agents in Python and .NET. New community resources (COMMUNITY.md, TRANSPARENCY\_FAQS.md) were added, while legacy documentation files (GLOSSARY.md, PROMPT\_TEMPLATE\_LANGUAGE.md) were removed. Additionally, the .NET development experience is improved by enforcing stricter code quality rules in .editorconfig (elevating many diagnostics to warnings, enabling Roslynator analyzers, and enforcing sealed classes) and by updating .gitignore to exclude modern development artifacts like .env files and IntelliJ/VS Code configurations.

(repo-wide) · high confidence

The internal JSON schema builder has been replaced to use Microsoft.Extensions.AI's AIJsonUtilities for generating schemas. This change removes the previous JsonSchema.Net dependency and aligns schema creation with the Microsoft.Extensions.AI library, ensuring compatibility with .NET 9+ and Native-AOT scenarios while maintaining backward compatibility with existing schema formats.

dotnet/src/InternalUtilities/src/Schema · high confidence

This release introduces significant breaking changes to the Semantic Kernel abstractions to modernize the API surface. The core \Kernel\ class now uses \IServiceProvider\ directly for service resolution and \KernelArguments\ instead of the removed \SKContext\ and \ContextVariables\. Construction is simplified via the new \Kernel.CreateBuilder()\ factory method, replacing the previous \KernelBuilder\ class. The event-based extension model is replaced by a new filter system (\IFunctionInvocationFilter\, \IPromptRenderFilter\, \IAutoFunctionInvocationFilter\) registered on the \Kernel\ instance. Additionally, \KernelException\ is now the unified base exception, \IAIServiceSelector\ uses a Try-pattern, and \AIRequestSettings\ is renamed to \PromptExecutionSettings\. A new \AbstractionsJsonContext\ enables source-generated JSON serialization for better Native AOT support.

dotnet/src/SemanticKernel.Abstractions · high confidence

The template engine's block classes (CodeBlock, FunctionIdBlock, NamedArgBlock, VarBlock, ValBlock, TextBlock) have been moved to SemanticKernel.Core and refactored to accept KernelArguments instead of the legacy ContextVariables. This change introduces support for named arguments in function calls (e.g., {{Plugin.Function arg=value}}), validates function identifiers to allow at most one dot, and standardizes rendering interfaces (ITextRendering, ICodeRendering) to use KernelArguments. The Block base class now handles logging via ILoggerFactory, and block types are expanded to include Value, FunctionId, and NamedArg.

dotnet/src/SemanticKernel.Core/TemplateEngine/Blocks · high confidence

The TextChunker class in SemanticKernel.Core has been updated to handle text splitting more robustly. When splitting plain text into paragraphs, embedded carriage returns and mixed line endings (\\r\\n, \\r) are now normalized to newlines (\\n) to prevent splitting issues. Additionally, the API now accepts an optional TokenCounter delegate, allowing users to provide a custom function for counting tokens; if omitted, a default counter based on string length is used, which reduces allocation overhead and external dependencies.

dotnet/src/SemanticKernel.Core/Text · high confidence

The .NET notebooks have been updated to require the .NET 10 SDK and reference Microsoft.SemanticKernel version 1.23.0. This change refreshes the getting-started and core demonstration notebooks (including basic kernel loading, prompt execution, inline functions, chat, function calling, vector stores, and DALL-E 3 integration) to align with the latest SDK release and runtime requirements.

dotnet/notebooks · high confidence

The Text-to-Image concept samples have been updated to demonstrate the new \ITextToImageService\ abstraction that supports \ExecutionSettings\. New examples for Azure OpenAI and OpenAI show how to generate images using \GetImageContentsAsync\ with \OpenAITextToImageExecutionSettings\, allowing users to specify image dimensions and retrieve results as either URIs or base64-encoded binary data. A legacy sample file is also included to illustrate the previous \GenerateImageAsync\ API for backward compatibility.

dotnet/samples/Concepts/TextToImage · high confidence

The gRPC functions in the Functions.Grpc package are now explicitly marked as experimental (SKEXP0040), indicating they are in a pre-release state and may undergo breaking changes. Additionally, the gRPC operation runner now enforces stricter security controls by validating URI schemes (defaulting to HTTPS only) and allowing administrators to restrict allowed base addresses to prevent Server-Side Request Forgery (SSRF) attacks.

dotnet/src/Functions/Functions.Grpc · high confidence

Added Azure AI Search integration test configuration and setup scripts; Added Dapr-based integration test runner for Semantic Kernel processes; Added Native-AOT compatibility test suite for Semantic Kernel; Added cross-language integration tests for prompt templates and OpenAPI plugins; Added fake email plugins for integration testing; Added integration and unit tests for the Experimental Flow Orchestrator; Added integration test infrastructure for text and vector search; Added integration tests for .NET agent implementations; Added integration tests for Agent text search provider conformance; Added integration tests for AgentThread conformance; Added integration tests for Amazon Bedrock connectors; Added integration tests for Azure OpenAI connectors; Added integration tests for Google AI embedding generation with custom dimensions; Added integration tests for Google Gemini chat and function calling; Added integration tests for Hugging Face text generation service; Added integration tests for HuggingFace Chat Completion service; Added integration tests for HuggingFace embedding generation; Added integration tests for KernelFunctionExtensions and Handlebars prompt support; Added integration tests for Mem0 and Whiteboard memory providers; Added integration tests for MistralAI chat completion; Added integration tests for MistralAI text embedding; Added integration tests for ONNX connectors; Added integration tests for OpenAI connector capabilities; Added integration tests for OpenAPI manifest plugin creation and import; Added integration tests for OpenAPI plugin creation and execution; Added integration tests for Semantic Kernel AI agent adapters; Added integration tests for agent invoke and AI context provider conformance; Added integration tests for agent invoke streaming conformance; Added integration tests for contextual function selection and sample plugin loading; Added integration tests for the Azure AI Inference connector; Added integration tests for the Ollama connector; Added integration tests for the Sessions Python Plugin; Added integration tests for web search and file download plugins; Added internationalization tests for TextChunker; Added test base classes for agent sample utilities; Added test data fixtures for Prompty unit tests; Added test fixtures for OpenAPI plugin parsing; Added test helper for console logging; Added test utilities for agent unit tests; Added test utilities for process unit testing; Added test utility infrastructure for internal unit tests; Added tests for Hugging Face text generation stream response parsing; Added unit and integration tests for Chroma and Milvus vector data connectors; Added unit tests for A2A and Copilot Studio agent adapters; Added unit tests for AI service conversion and prompt execution settings; Added unit tests for Agent definition, tool, and response extensions; Added unit tests for AgentGroupChat strategies and settings; Added unit tests for AggregatorAgentFactory; Added unit tests for Amazon Bedrock connector extensions; Added unit tests for Amazon Bedrock execution settings; Added unit tests for AutoFunctionInvocationContext; Added unit tests for Azure AI Agent extension methods and message factory; Added unit tests for Azure AI Inference ChatClientCore; Added unit tests for Azure AI Inference chat completion service and OpenTelemetry integration; Added unit tests for Azure AI Inference connector extension methods; Added unit tests for Azure AI Inference prompt execution settings; Added unit tests for Azure AI agent adapters and configuration options; Added unit tests for Azure OpenAI connector core initialization and retry behavior; Added unit tests for Azure OpenAI connector services; Added unit tests for Azure OpenAI kernel and service collection extensions; Added unit tests for Azure OpenAI prompt execution settings; Added unit tests for AzureAIAgentFactory; Added unit tests for Bedrock Agent and Channel; Added unit tests for Bedrock agent extensions and function schema conversions; Added unit tests for BroadcastQueue and KeyEncoder; Added unit tests for ChatMessageForPrompt history formatting; Added unit tests for ChatPromptParser and XmlPromptParser; Added unit tests for ContextualFunctionProvider and FunctionStore; Added unit tests for Copilot Studio agent components; Added unit tests for Core, Document, Memory, and MsGraph plugins; Added unit tests for Dapr Process runtime serialization and step validation; Added unit tests for Function Choice Behaviors; Added unit tests for FunctionCallContentBuilder; Added unit tests for FunctionCallsProcessor; Added unit tests for FunctionInvokedEventArgs; Added unit tests for Google AI and Vertex AI embedding and chat services; Added unit tests for Google AI embedding generation and request serialization; Added unit tests for Google Gemini client function calling and security hardening; Added unit tests for Google Gemini connector configuration and tool call behavior; Added unit tests for Google and Vertex AI connector extension methods; Added unit tests for Handlebars prompt template factory and rendering; Added unit tests for Handlebars prompt template helpers; Added unit tests for Hugging Face connector services; Added unit tests for HuggingFace connector initialization and configuration; Added unit tests for Kernel Process components; Added unit tests for Kernel and HttpMessageHandlerStub; Added unit tests for Liquid prompt template rendering and safety handling; Added unit tests for Magentic agent orchestration components; Added unit tests for Memory subsystem components; Added unit tests for MistralAI chat and embedding services; Added unit tests for MistralAI client; Added unit tests for ONNX connector configuration and service registration; Added unit tests for Ollama KernelBuilder and ServiceCollection extensions; Added unit tests for OllamaPromptExecutionSettings; Added unit tests for OpenAI Agent extension methods; Added unit tests for OpenAI Agent internal factories and actions; Added unit tests for OpenAI Assistant Agent Factory; Added unit tests for OpenAI audio and prompt execution settings; Added unit tests for OpenAI connector core components; Added unit tests for OpenAI connector extension methods; Added unit tests for OpenAI connector services; Added unit tests for OpenAI pipeline utilities; Added unit tests for OpenAIChatResponseFormatBuilder; Added unit tests for OpenAPI parameter serialization; Added unit tests for OpenAPI plugin functionality; Added unit tests for OpenAPI plugin import and schema handling; Added unit tests for Process Core builder components; Added unit tests for Prompty function creation and execution settings; Added unit tests for Semantic Kernel AIAgent adapters; Added unit tests for Semantic Kernel Data text search capabilities; Added unit tests for Semantic Kernel Functions; Added unit tests for Semantic Kernel content types; Added unit tests for Semantic Kernel utility components; Added unit tests for Template Engine block types and tokenizers; Added unit tests for VertexAI embeddings generation and request construction; Added unit tests for YAML-based Kernel function creation and execution settings; Added unit tests for YAML-based agent definition and factory creation; Added unit tests for YAML-based function choice behavior configuration; Added unit tests for YAML-based plugin creation and import; Added unit tests for agent definition models and factories; Added unit tests for agent orchestration components; Added unit tests for chat completion integration and history management; Added unit tests for chat message and exception extension methods; Added unit tests for core Agent Framework components; Added unit tests for gRPC Protobuf document parsing; Added unit tests for gRPC operation parameter creation; Added unit tests for gRPC plugin address handling and security; Added unit tests for kernel function usage metrics telemetry; Added unit tests for process cloning and type extension utilities; Added unit tests for prompt template factories and configuration; Added unit tests for the .NET Agent Framework; Added unit tests for the CrewAI Enterprise plugin; Added unit tests for the Freezable utility class; Integration tests for the Common Agent Interface across multiple agent providers; Removal of legacy unit tests for core SemanticKernel components; Shared integration tests for Semantic Kernel Processes; Unit tests for OpenAI Assistant and Response agents.

A dependency / build maintenance change in (dependencies) — 1196 commits (65 fixs), 188 files.

(dependencies) · high confidence · unverified

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 59.

• Code Health 53
• Architecture 82
• Maturity 75
• Readiness 56
• Security 67
• Event-Driven 100
• Performance 65

• 300 commits — 259 feature/other, 41 fixes

• dotnet/src — 98 commits
• python/semantic_kernel — 54 commits
• dotnet/samples — 22 commits
• dotnet/Directory.Packages.props — 17 commits
• dotnet/nuget — 16 commits
• python/pyproject.toml — 16 commits
• .github/workflows — 14 commits
• python/uv.lock — 14 commits
• python/tests — 12 commits
• dotnet/test — 11 commits
• python/samples — 8 commits
• (repo) — 4 commits
• (root) — 4 commits
• dotnet/global.json — 3 commits
• dotnet/SK-release.slnf — 2 commits
• .devcontainer/devcontainer.json — 1 commit
• .github/actions — 1 commit
• .github/upgrades — 1 commit
• .vscode/extensions.json — 1 commit
• dotnet/nuget.config — 1 commit

• fix: .NET Fix - Surface agent failure for orchestration (#13369)
• fix: .Net: Bump Snappier to 1.3.1 to fix NU1903 high-severity vulnerability ([GHSA redacted]) (#13960)
• fix: .Net: Fix #13232: Add empty parameters schema for NonInvocableTool placeholder (#13278)
• fix: .Net: Fix #13262: GeminiRequest to handle single turn requests correctly (#13288)
• fix: .Net: Fix DocumentPlugin path validation order (#13956)
• fix: .Net: Fix GeminiChatCompletionClient to invoke IAutoFunctionInvocationFilter during auto function calling (#13397)
• fix: .Net: Fix VertexAI global endpoint URI construction (#13620) (#13621)
• fix: .Net: Fix column nullability in SQL MEVD providers (#13622)
• fix: .Net: Fix input checking in Cosmos NoSQL, Redis and Weaviate providers (#13629)
• fix: .Net: Fix single-quote escaping in OBJECT_ID and dynamic SQL string literals (#13900)
• fix: .Net: Fix top/skip bug in Azure AI Search (#13326)
• fix: .Net: Fix: include taskType in Google AI embedding request (fixes #13250) (#13277)
• fix: .Net: Fixes Qdrant 1.17 issue with returning empty vectors (#13638)
• fix: .Net: Pin SharpCompress 0.48.0 to fix [GHSA redacted] (#13977)
• fix: .Net: [MEVD] Fix Guid (and other) keys for dynamic collections (#13341)
• fix: .Net: [MEVD] Fix dynamic batching APIs for PostgreSQL (#13323)
• fix: .Net: fix: AutorRole.Developer missing (#13310)
• fix: .Net: fix: address three static analysis issues (audio format, text search, KernelProcess) (#13925)
• fix: .Net: fix: fall back to ToString() when logging function results with unregistered types (#13884)
• fix: .Net: fix: prevent duplicate "null" in JSON Schema type arrays for nullable parameters (#13635)
• …and 280 more

• 10 HTTP endpoints (baseline)

• 0 containers · 3 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

microsoft/semantic-kernel was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.