AgentNet.InProcess.Polly-v1.0.0-rc.5

AgentNet.InProcess.Polly v1.0.0-rc.5

• Releases AgentNet.InProcess.Polly-v1.0.0-rc.5 -- which should have been released in lockstep with AgentNet.InProcess-v1.0.0-rc.5.

Full Changelog: AgentNet.InProcess-v1.0.0-rc.5...AgentNet.InProcess.Polly-v1.0.0-rc.5

AgentNet.InProcess-v1.0.0-rc.5

AgentNet.InProcess v1.0.0-rc.5

What's Changed

• Fix exception swallowing in MAF in-process execution by @OnurGumus in #4

Full Changelog: v1.0.0-rc.4...AgentNet.InProcess-v1.0.0-rc.5

v1.0.0-rc.4

AgentNet & AgentNet.InProcess — v1.0.0‑rc.4

This release builds directly on the rich streaming model introduced in v1.0.0‑rc.3, and delivers a major architectural milestone: a clean separation of runtimes, a new decorator system, and an optional Polly integration package.

Together, rc3 + rc4 form the foundation for the final 1.0 release.

---

🚀 What’s New in rc.4

1. New InProcess Runtime Package

The InProcess runtime has been extracted into its own package:

• AgentNet.InProcess

This clarifies the boundary between:

• Durable (deterministic, replay‑safe)
• InProcess (nondeterministic, runtime‑only behaviors)

This separation makes the architecture easier to understand, extend, and maintain.

---

2. New decorate Operation (InProcess Runtime)

A new first‑class decorator mechanism enables runtime‑only behaviors:

decorate (policy retryPipeline)

Decorators can:

• wrap steps
• add logging, metrics, tracing
• apply resilience strategies
• modify runtime behavior without touching the DSL

This is the foundation for a whole ecosystem of runtime extensions.

---

3. New Polly Integration Package

Polly integration has been extracted into:

• AgentNet.InProcess.Polly

This package provides:

• retry
• timeout
• circuit breaker
• hedging
• rate limiting

…all via the new decorator system.

Polly is now optional, runtime‑only, and cleanly separated from the core.

---

🌱 Improvements & Internal Cleanup

• Extracted WorkflowBuilder into its own file
• Renamed internal files for clarity
• Removed Polly references from core
• Added safeguards around InProcess step decoration
• Improved ergonomics and readability across the runtime boundary

---

🌈 Highlights from rc3 (Still Relevant!)

rc4 builds on the major features introduced yesterday:

Rich Streaming API

• incremental text deltas
• tool‑call deltas (start, delta, end)
• reasoning deltas
• final completion event

ToolCallUpdate Enhancements

• stable tool call IDs
• partial JSON argument deltas
• late‑bound tool names

MAF Runtime Alignment

• consistent tool‑call semantics
• stable session management
• correct streaming behavior

Durable Improvements

• deterministic replay
• stable orchestration behavior
• cancellation token threading (Onur’s contribution)

These remain core to the AgentNet experience and are fully supported in rc4.

---

📦 Why rc4 Matters

This release completes the architectural foundation for 1.0:

• clean runtime separation
• expressive decorator system
• optional Polly integration
• unified build pipeline
• continued support for the rich streaming model from rc3

AgentNet is now positioned for a stable, polished 1.0 release.

---

v1.0.0-rc.3

AgentNet & AgentNet.Durable — v1.0.0‑rc.3

This release brings the AgentNet ecosystem into alignment with the latest Microsoft Agents Framework (MAF) rc4 runtime and introduces a major new capability: rich streaming support with tool‑call deltas and reasoning updates.
It also stabilizes Durable orchestration behavior and improves the developer experience across both packages.

---

🚀 What’s New

Rich Streaming API (AgentNet)

AgentNet now exposes a unified, expressive streaming model that delivers:

• incremental text deltas
• structured tool‑call updates (start, deltas, end)
• reasoning deltas
• a final completion event

All via a clean F# DU:

type ChatStreamEvent =
    | TextDelta of string
    | ToolCallDelta of ToolCallUpdate
    | ReasoningDelta of string
    | Completed of ChatResponse

And a new API surface:

ChatStream : string -> IAsyncEnumerable<ChatStreamEvent>

This gives downstream developers full fidelity over the model’s incremental output while keeping the API simple and intention‑revealing.

---

ToolCallUpdate Enhancements

Tool‑call streaming now includes:

• stable tool call IDs
• late‑bound tool names
• partial JSON argument deltas
• explicit start/end markers

This enables richer agent UIs, debugging tools, and multi‑tool workflows.

---

MAF Runtime Alignment

Both packages now align with the latest MAF rc4 runtime and Extensions.AI versions, ensuring:

• consistent tool‑call semantics
• correct streaming behavior
• stable session management
• predictable dependency resolution

---

🧹 Quality & Stability

• Removed stale dependency overrides
• Ensured explicit version pinning for Extensions.AI
• Improved internal mapping logic for MAF streaming events
• Added safeguards around session initialization and enumerator behavior
• Cleaned up the public API surface for clarity and consistency

---

📦 Why This Release Matters

v1.0.0‑rc.3 is the most stable and expressive version of AgentNet to date.
It delivers:

• a modern, future‑proof streaming model
• deterministic Durable orchestration
• clean dependency alignment
• a polished developer experience

This release sets the stage for the final 1.0.

---

Agent.NET v1.0.0-rc.1

AgentNet & AgentNet.Durable — v1.0.0‑rc.1

This release brings both AgentNet and AgentNet.Durable packages into alignment with the Microsoft Agents Framework (MAF) v1.0.0‑rc2 runtime.
It stabilizes the workflow model, finalizes durable orchestration behavior, and prepares the ecosystem for the upcoming 1.0 release.

---

What’s New

MAF Runtime Alignment

• Upgraded all Microsoft.Agents.* dependencies to v1.0.0‑rc2.
• Ensures compatibility with the finalized workflow envelopes, deterministic execution model, and replay semantics.

AgentNet Core Improvements

• All unit tests pass against the rc2 runtime, confirming stability of:
  • the instruction graph
  • deterministic step boundaries
  • pure, intention‑revealing workflow definitions
• Dependency versions aligned across the solution (including FSharp.Core).

AgentNet.Durable Enhancements

• Durable orchestrations now correctly suspend and resume using rc2’s stable state machine.
• External events (e.g., approvals) now resume workflows as intended.
• Removed preview-era behavior where orchestrators ran to completion without yielding.
• Updated sample Durable Functions project to match rc2 DurableTask behavior.

Sample Workflow Fixes

• Trade Approval sample now:
  • waits for approval
  • resumes correctly
  • completes with the expected output
• Improved consistency across all sample projects.

---

Why This Release Matters

This milestone brings the entire Agent.NET ecosystem into alignment with the near-final MAF 1.0 surface.
It stabilizes durable execution, ensures deterministic behavior, and sets the stage for a clean, predictable 1.0 release.

v1.0.0-alpha.3

1.0.0‑alpha.3

This release introduces tryStep, a first‑class way to express typed early‑exit behavior directly inside the main workflow DSL. It replaces the old ResultWorkflow computation expression, offering a simpler, more expressive, and more ergonomic approach to Railway‑Oriented Programming.

✨ Added

• tryStep — a workflow step that returns a Result and short‑circuits the workflow on Error.
  This brings Railway‑Oriented Programming into the core DSL without requiring a separate computation expression.

🛠️ Changed

• Removed ResultWorkflow in favor of tryStep.
  The new design is clearer, avoids monadic contagion, and integrates naturally with both in‑process and Durable workflows.

🔧 Improved

• Refined README structure:
  • Added a concise introduction to tryStep under Features.
  • Replaced redundant sections and improved overall clarity.
  • Added tables for Workflow, Tool, and Agent functions for easier scanning.

1.0.0-alpha.2

v1.0.0-alpha.2

Durable Workflows & Major Refinements

New: AgentNet.Durable Package

Host Agent.NET long-running, enterprise workflows reliably on Azure Durable Functions.
This is the final form of workflow execution in Agent.NET — declarative, typed, and minimal.

let tradeApprovalWorkflow = workflow {
    name "TradeApprovalWorkflow"
    step analyzeStock
    step sendForApproval
    awaitEvent "TradeApproval" eventOf<ApprovalDecision>
    step executeTrade
}

[<Function("TradeApprovalOrchestrator")>]
let orchestrator ([<OrchestrationTrigger>] ctx) =
    let request = ctx.GetInput<TradeRequest>()
    Workflow.Durable.run ctx request tradeApprovalWorkflow

• awaitEvent — suspend workflows waiting for external events (human-in-the-loop patterns)
• Durable execution powered by Microsoft Agent Framework and Azure Durable Functions with automatic checkpointing
• Minimal hosting surface — the orchestrator simply runs the workflow

Workflow CE: Stronger Typing, Cleaner Syntax

The Workflow computation expression has matured into a more predictable, more expressive DSL for defining long‑running workflows.

• SRTP type inference
  Steps now infer input/output types more reliably, reducing annotation noise and making workflows feel more “F#‑native.”
• Plug‑and‑play step composition
  Each step can now be a plain function, Task, Async, TypedAgent, or even a nested workflow — all with consistent typing and execution semantics.
• Compiler‑enforced I/O correctness
  The CE now enforces that each step’s output matches the next step’s input, eliminating entire classes of runtime errors.
• Simplified API surface
  Redundant helpers and experimental constructs have been removed or unified, leaving a smaller, more intentional API.
• Fan‑out ergonomics
  Parallel branches are easier to express and reason about, with clearer type signatures and more predictable behavior.

Why this matters:
Workflows now read like clean, declarative pipelines — and the compiler guarantees correctness.

TypedAgent: Structured, Typed Agent Execution

A new agent type that brings structure and safety to LLM‑powered steps.

• Typed input/output
  Define agents with explicit request and response types for predictable, validated boundaries.
• Prompt + parse model
  Each agent combines a prompt generator with a typed parser, giving you full control over structure and error handling.
• Upgrade path from ChatAgent
  ChatAgent remains supported, but TypedAgent is now the recommended way to build reliable agent steps.

Why this matters:
You get the flexibility of LLM agents with the safety of typed contracts — ideal for workflows that must be correct, resumable, and durable.

Architecture: Cleaner, Safer, More Predictable

This release includes major internal refinements that make Agent.NET more robust and easier to reason about.

• MAF InProcessExecution replaces the prototype runner
  Local execution now mirrors durable execution semantics, reducing conceptual drift between hosts.

• Removal of reflection and obj
  Internal step representation is now fully typed, eliminating reflection‑based dispatch and improving safety.

• C# executors for serialization boundaries
  Durable Functions serialization is now handled internally by explicit C# executors, ensuring compatibility and clarity.

• Stronger internal step model
  Steps are now represented in a more explicit, typed form, improving debuggability and reducing edge cases.

Why this matters:
The engine is now more predictable, more maintainable, and better aligned with the durable execution model.

Cleanup & Polish

• Multi‑targeting for broader compatibility: net8.0, net9.0, net10.0
• Numerous bug fixes and stability improvements
• Durable hosting hardened for real‑world workloads

v1.0.0-alpha.1

v1.0.0-alpha.1

Agent.NET - First Alpha Release 🎉

Elegant agent workflows for .NET, designed in F#.

Highlights

• Quotation-based Tool creation - Use Tool.create <@ myFunction @> to automatically extract function name, parameter names, and types. Use Tool.createWithDocs to also pull XML documentation as descriptions.
• Pipeline-style ChatAgent API - Build agents with a clean, composable pipeline:

ChatAgent.create "You are a helpful assistant."
|> ChatAgent.withTools [tool1; tool2]
|> ChatAgent.build chatClient

• Workflow computation expression - Orchestrate multi-step agent workflows with:
  • Sequential pipelines (step)
  • Parallel execution (fanOut / fanIn)
  • Conditional routing (route)
  • Resilience patterns (retry, timeout, fallback, backoff)
• ResultWorkflow - Railway-oriented programming with automatic error short-circuiting
• In-memory execution via Workflow.runInProcess

This alpha wraps https://github.com/microsoft/agent-framework with idiomatic F# APIs. Feedback welcome!