diff --git a/runtime/csharp/Prompty.Anthropic/AnthropicExecutor.cs b/runtime/csharp/Prompty.Anthropic/AnthropicExecutor.cs
index e936c00c..cfc2313e 100644
--- a/runtime/csharp/Prompty.Anthropic/AnthropicExecutor.cs
+++ b/runtime/csharp/Prompty.Anthropic/AnthropicExecutor.cs
@@ -105,11 +105,18 @@ async IAsyncEnumerable<object> StreamEvents([System.Runtime.CompilerServices.Enu
         if (stream)
             body["stream"] = true;
 
+        // Apply model options via generated wire mapping
         var opts = agent.Model?.Options;
-        if (opts?.Temperature is not null) body["temperature"] = opts.Temperature;
-        if (opts?.TopP is not null) body["top_p"] = opts.TopP;
-        if (opts?.TopK is not null) body["top_k"] = opts.TopK;
-        if (opts?.StopSequences is not null) body["stop_sequences"] = opts.StopSequences;
+        if (opts is not null)
+        {
+            var wireOpts = opts.ToWire("anthropic");
+            // max_tokens is handled separately above with DefaultMaxTokens fallback
+            wireOpts.Remove("max_tokens");
+            foreach (var (key, value) in wireOpts)
+            {
+                body[key] = value;
+            }
+        }
 
         var tools = ToolsToWire(agent);
         if (tools is not null) body["tools"] = tools;
@@ -147,7 +154,7 @@ private static HttpRequestMessage CreateRequest(string endpoint, string apiKey,
         // Handle tool results
         if (msg.Role == Roles.Tool)
         {
-            var toolCallId = msg.Metadata.TryGetValue("tool_call_id", out var id)
+            var toolCallId = msg.Metadata is not null && msg.Metadata.TryGetValue("tool_call_id", out var id)
                 ? id?.ToString() ?? ""
                 : "";
             return new Dictionary<string, object?>
diff --git a/runtime/csharp/Prompty.Core.Tests/AgentLoopIntegrationTests.cs b/runtime/csharp/Prompty.Core.Tests/AgentLoopIntegrationTests.cs
index e80f8a8f..73833dbc 100644
--- a/runtime/csharp/Prompty.Core.Tests/AgentLoopIntegrationTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/AgentLoopIntegrationTests.cs
@@ -22,7 +22,7 @@ public Task<string> RenderAsync(Prompty agent, string template, Dictionary<strin
 /// </summary>
 file class PassthroughParser : IParser
 {
-    public Task<List<Message>> ParseAsync(Prompty agent, string rendered)
+    public Task<List<Message>> ParseAsync(Prompty agent, string rendered, Dictionary<string, object?>? context)
         => Task.FromResult(new List<Message>
         {
             new() { Role = Roles.User, Parts = [new TextPart { Value = rendered }] }
@@ -35,7 +35,7 @@ public Task<List<Message>> ParseAsync(Prompty agent, string rendered)
 /// </summary>
 file class MultiMessageParser : IParser
 {
-    public Task<List<Message>> ParseAsync(Prompty agent, string rendered)
+    public Task<List<Message>> ParseAsync(Prompty agent, string rendered, Dictionary<string, object?>? context)
     {
         var filler = new string('z', 300);
         return Task.FromResult(new List<Message>
@@ -282,7 +282,7 @@ public async Task InputGuardrail_RewritesMessages_ExecutorSeesRewritten()
         };
 
         var guardrails = new Guardrails(
-            input: _ => new GuardrailResult(true, Rewrite: rewritten));
+            input: _ => new GuardrailResult(true, rewrite: rewritten));
 
         var result = await Pipeline.TurnAsync(agent, guardrails: guardrails);
 
@@ -327,7 +327,7 @@ public async Task OutputGuardrail_RewritesResponse_ReturnsSanitised()
 
         var agent = AgentLoopHelper.CreateAgent();
         var guardrails = new Guardrails(
-            output: _ => new GuardrailResult(true, Rewrite: "redacted answer"));
+            output: _ => new GuardrailResult(true, rewrite: "redacted answer"));
 
         var result = await Pipeline.TurnAsync(agent, guardrails: guardrails);
 
@@ -367,7 +367,7 @@ public async Task ToolGuardrail_RewritesArgs_ToolReceivesRewrittenArgs()
 
         var rewrittenArgs = new Dictionary<string, object?> { ["city"] = "Seattle" };
         var guardrails = new Guardrails(
-            tool: (name, args) => new GuardrailResult(true, Rewrite: rewrittenArgs));
+            tool: (name, args) => new GuardrailResult(true, rewrite: rewrittenArgs));
 
         var result = await Pipeline.TurnAsync(agent, tools: tools, guardrails: guardrails);
 
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/AnonymousConnectionConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/AnonymousConnectionConversionTests.cs
index 0f6fa882..874f9da2 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/AnonymousConnectionConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/AnonymousConnectionConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ApiKeyConnectionConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ApiKeyConnectionConversionTests.cs
index 3371ce0e..08653272 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/ApiKeyConnectionConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ApiKeyConnectionConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ArrayPropertyConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ArrayPropertyConversionTests.cs
index fa4a746e..f5c0bd95 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/ArrayPropertyConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ArrayPropertyConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/AudioPartConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/AudioPartConversionTests.cs
new file mode 100644
index 00000000..f30c32f9
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/AudioPartConversionTests.cs
@@ -0,0 +1,122 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class AudioPartConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+source: "https://example.com/audio.wav"
+mediaType: audio/wav
+
+""";
+
+        var instance = AudioPart.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("https://example.com/audio.wav", instance.Source);
+        Assert.Equal("audio/wav", instance.MediaType);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "source": "https://example.com/audio.wav",
+  "mediaType": "audio/wav"
+}
+""";
+
+        var instance = AudioPart.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("https://example.com/audio.wav", instance.Source);
+        Assert.Equal("audio/wav", instance.MediaType);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "source": "https://example.com/audio.wav",
+  "mediaType": "audio/wav"
+}
+""";
+
+        var original = AudioPart.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = AudioPart.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("https://example.com/audio.wav", reloaded.Source);
+        Assert.Equal("audio/wav", reloaded.MediaType);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+source: "https://example.com/audio.wav"
+mediaType: audio/wav
+
+""";
+
+        var original = AudioPart.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = AudioPart.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("https://example.com/audio.wav", reloaded.Source);
+        Assert.Equal("audio/wav", reloaded.MediaType);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "source": "https://example.com/audio.wav",
+  "mediaType": "audio/wav"
+}
+""";
+
+        var instance = AudioPart.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+source: "https://example.com/audio.wav"
+mediaType: audio/wav
+
+""";
+
+        var instance = AudioPart.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/BindingConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/BindingConversionTests.cs
index 63c7756e..5ae77e47 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/BindingConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/BindingConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
@@ -120,6 +119,7 @@ public void ToYamlProducesValidYaml()
         var parsed = deserializer.Deserialize<object>(yaml);
         Assert.NotNull(parsed);
     }
+
     [Fact]
     public void LoadJsonFromString()
     {
@@ -137,7 +137,7 @@ public void LoadYamlFromString()
         var data = "\"example\"";
         var instance = Binding.FromYaml(data);
         Assert.NotNull(instance);
+
         Assert.Equal("example", instance.Input);
     }
-
 }
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/CompactionCompletePayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/CompactionCompletePayloadConversionTests.cs
new file mode 100644
index 00000000..40f3a6c2
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/CompactionCompletePayloadConversionTests.cs
@@ -0,0 +1,122 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class CompactionCompletePayloadConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+removed: 5
+remaining: 3
+
+""";
+
+        var instance = CompactionCompletePayload.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal(5, instance.Removed);
+        Assert.Equal(3, instance.Remaining);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "removed": 5,
+  "remaining": 3
+}
+""";
+
+        var instance = CompactionCompletePayload.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal(5, instance.Removed);
+        Assert.Equal(3, instance.Remaining);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "removed": 5,
+  "remaining": 3
+}
+""";
+
+        var original = CompactionCompletePayload.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = CompactionCompletePayload.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal(5, reloaded.Removed);
+        Assert.Equal(3, reloaded.Remaining);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+removed: 5
+remaining: 3
+
+""";
+
+        var original = CompactionCompletePayload.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = CompactionCompletePayload.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal(5, reloaded.Removed);
+        Assert.Equal(3, reloaded.Remaining);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "removed": 5,
+  "remaining": 3
+}
+""";
+
+        var instance = CompactionCompletePayload.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+removed: 5
+remaining: 3
+
+""";
+
+        var instance = CompactionCompletePayload.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/CompactionConfigConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/CompactionConfigConversionTests.cs
new file mode 100644
index 00000000..31c383c3
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/CompactionConfigConversionTests.cs
@@ -0,0 +1,137 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class CompactionConfigConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+strategy: summarize
+budget: 50000
+options:
+  preserveSystemMessages: true
+
+""";
+
+        var instance = CompactionConfig.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("summarize", instance.Strategy);
+        Assert.Equal(50000, instance.Budget);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "strategy": "summarize",
+  "budget": 50000,
+  "options": {
+    "preserveSystemMessages": true
+  }
+}
+""";
+
+        var instance = CompactionConfig.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("summarize", instance.Strategy);
+        Assert.Equal(50000, instance.Budget);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "strategy": "summarize",
+  "budget": 50000,
+  "options": {
+    "preserveSystemMessages": true
+  }
+}
+""";
+
+        var original = CompactionConfig.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = CompactionConfig.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("summarize", reloaded.Strategy);
+        Assert.Equal(50000, reloaded.Budget);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+strategy: summarize
+budget: 50000
+options:
+  preserveSystemMessages: true
+
+""";
+
+        var original = CompactionConfig.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = CompactionConfig.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("summarize", reloaded.Strategy);
+        Assert.Equal(50000, reloaded.Budget);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "strategy": "summarize",
+  "budget": 50000,
+  "options": {
+    "preserveSystemMessages": true
+  }
+}
+""";
+
+        var instance = CompactionConfig.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+strategy: summarize
+budget: 50000
+options:
+  preserveSystemMessages: true
+
+""";
+
+        var instance = CompactionConfig.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/CompactionFailedPayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/CompactionFailedPayloadConversionTests.cs
new file mode 100644
index 00000000..23093a66
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/CompactionFailedPayloadConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class CompactionFailedPayloadConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+message: Summarization prompt exceeded context window
+
+""";
+
+        var instance = CompactionFailedPayload.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("Summarization prompt exceeded context window", instance.Message);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "message": "Summarization prompt exceeded context window"
+}
+""";
+
+        var instance = CompactionFailedPayload.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("Summarization prompt exceeded context window", instance.Message);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "message": "Summarization prompt exceeded context window"
+}
+""";
+
+        var original = CompactionFailedPayload.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = CompactionFailedPayload.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Summarization prompt exceeded context window", reloaded.Message);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+message: Summarization prompt exceeded context window
+
+""";
+
+        var original = CompactionFailedPayload.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = CompactionFailedPayload.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Summarization prompt exceeded context window", reloaded.Message);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "message": "Summarization prompt exceeded context window"
+}
+""";
+
+        var instance = CompactionFailedPayload.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+message: Summarization prompt exceeded context window
+
+""";
+
+        var instance = CompactionFailedPayload.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ConnectionConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ConnectionConversionTests.cs
index 6e258e5d..2c597798 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/ConnectionConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ConnectionConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ContentPartConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ContentPartConversionTests.cs
new file mode 100644
index 00000000..148e1f1d
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ContentPartConversionTests.cs
@@ -0,0 +1,10 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ContentPartConversionTests
+{
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/CustomToolConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/CustomToolConversionTests.cs
index 489dbf69..9586ab5e 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/CustomToolConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/CustomToolConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/DoneEventPayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/DoneEventPayloadConversionTests.cs
new file mode 100644
index 00000000..1211f745
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/DoneEventPayloadConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class DoneEventPayloadConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+response: The weather in Paris is 72°F and sunny.
+
+""";
+
+        var instance = DoneEventPayload.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("The weather in Paris is 72°F and sunny.", instance.Response);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "response": "The weather in Paris is 72°F and sunny."
+}
+""";
+
+        var instance = DoneEventPayload.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("The weather in Paris is 72°F and sunny.", instance.Response);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "response": "The weather in Paris is 72°F and sunny."
+}
+""";
+
+        var original = DoneEventPayload.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = DoneEventPayload.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("The weather in Paris is 72°F and sunny.", reloaded.Response);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+response: The weather in Paris is 72°F and sunny.
+
+""";
+
+        var original = DoneEventPayload.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = DoneEventPayload.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("The weather in Paris is 72°F and sunny.", reloaded.Response);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "response": "The weather in Paris is 72°F and sunny."
+}
+""";
+
+        var instance = DoneEventPayload.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+response: The weather in Paris is 72°F and sunny.
+
+""";
+
+        var instance = DoneEventPayload.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ErrorChunkConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ErrorChunkConversionTests.cs
new file mode 100644
index 00000000..16153964
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ErrorChunkConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ErrorChunkConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+message: Rate limit exceeded
+
+""";
+
+        var instance = ErrorChunk.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("Rate limit exceeded", instance.Message);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "message": "Rate limit exceeded"
+}
+""";
+
+        var instance = ErrorChunk.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("Rate limit exceeded", instance.Message);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "message": "Rate limit exceeded"
+}
+""";
+
+        var original = ErrorChunk.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ErrorChunk.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Rate limit exceeded", reloaded.Message);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+message: Rate limit exceeded
+
+""";
+
+        var original = ErrorChunk.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ErrorChunk.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Rate limit exceeded", reloaded.Message);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "message": "Rate limit exceeded"
+}
+""";
+
+        var instance = ErrorChunk.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+message: Rate limit exceeded
+
+""";
+
+        var instance = ErrorChunk.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ErrorEventPayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ErrorEventPayloadConversionTests.cs
new file mode 100644
index 00000000..d3cc78e2
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ErrorEventPayloadConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ErrorEventPayloadConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+message: Rate limit exceeded
+
+""";
+
+        var instance = ErrorEventPayload.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("Rate limit exceeded", instance.Message);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "message": "Rate limit exceeded"
+}
+""";
+
+        var instance = ErrorEventPayload.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("Rate limit exceeded", instance.Message);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "message": "Rate limit exceeded"
+}
+""";
+
+        var original = ErrorEventPayload.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ErrorEventPayload.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Rate limit exceeded", reloaded.Message);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+message: Rate limit exceeded
+
+""";
+
+        var original = ErrorEventPayload.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ErrorEventPayload.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Rate limit exceeded", reloaded.Message);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "message": "Rate limit exceeded"
+}
+""";
+
+        var instance = ErrorEventPayload.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+message: Rate limit exceeded
+
+""";
+
+        var instance = ErrorEventPayload.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/FilePartConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/FilePartConversionTests.cs
new file mode 100644
index 00000000..9d5e98dd
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/FilePartConversionTests.cs
@@ -0,0 +1,122 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class FilePartConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+source: "https://example.com/document.pdf"
+mediaType: application/pdf
+
+""";
+
+        var instance = FilePart.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("https://example.com/document.pdf", instance.Source);
+        Assert.Equal("application/pdf", instance.MediaType);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "source": "https://example.com/document.pdf",
+  "mediaType": "application/pdf"
+}
+""";
+
+        var instance = FilePart.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("https://example.com/document.pdf", instance.Source);
+        Assert.Equal("application/pdf", instance.MediaType);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "source": "https://example.com/document.pdf",
+  "mediaType": "application/pdf"
+}
+""";
+
+        var original = FilePart.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = FilePart.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("https://example.com/document.pdf", reloaded.Source);
+        Assert.Equal("application/pdf", reloaded.MediaType);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+source: "https://example.com/document.pdf"
+mediaType: application/pdf
+
+""";
+
+        var original = FilePart.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = FilePart.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("https://example.com/document.pdf", reloaded.Source);
+        Assert.Equal("application/pdf", reloaded.MediaType);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "source": "https://example.com/document.pdf",
+  "mediaType": "application/pdf"
+}
+""";
+
+        var instance = FilePart.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+source: "https://example.com/document.pdf"
+mediaType: application/pdf
+
+""";
+
+        var instance = FilePart.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/FormatConfigConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/FormatConfigConversionTests.cs
index a4ad1ca3..b93f51bf 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/FormatConfigConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/FormatConfigConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
@@ -135,6 +134,7 @@ public void ToYamlProducesValidYaml()
         var parsed = deserializer.Deserialize<object>(yaml);
         Assert.NotNull(parsed);
     }
+
     [Fact]
     public void LoadJsonFromString()
     {
@@ -152,7 +152,7 @@ public void LoadYamlFromString()
         var data = "\"example\"";
         var instance = FormatConfig.FromYaml(data);
         Assert.NotNull(instance);
+
         Assert.Equal("example", instance.Kind);
     }
-
 }
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/FoundryConnectionConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/FoundryConnectionConversionTests.cs
index 6d08b1a8..e8b36bf4 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/FoundryConnectionConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/FoundryConnectionConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/FunctionToolConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/FunctionToolConversionTests.cs
index 08ce7851..079b3c9c 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/FunctionToolConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/FunctionToolConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/GuardrailResultConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/GuardrailResultConversionTests.cs
new file mode 100644
index 00000000..1f5aa6e3
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/GuardrailResultConversionTests.cs
@@ -0,0 +1,146 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class GuardrailResultConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+allowed: true
+reason: Content is safe
+
+""";
+
+        var instance = GuardrailResult.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.True(instance.Allowed);
+        Assert.Equal("Content is safe", instance.Reason);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "allowed": true,
+  "reason": "Content is safe"
+}
+""";
+
+        var instance = GuardrailResult.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.True(instance.Allowed);
+        Assert.Equal("Content is safe", instance.Reason);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "allowed": true,
+  "reason": "Content is safe"
+}
+""";
+
+        var original = GuardrailResult.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = GuardrailResult.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.True(reloaded.Allowed);
+        Assert.Equal("Content is safe", reloaded.Reason);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+allowed: true
+reason: Content is safe
+
+""";
+
+        var original = GuardrailResult.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = GuardrailResult.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.True(reloaded.Allowed);
+        Assert.Equal("Content is safe", reloaded.Reason);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "allowed": true,
+  "reason": "Content is safe"
+}
+""";
+
+        var instance = GuardrailResult.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+allowed: true
+reason: Content is safe
+
+""";
+
+        var instance = GuardrailResult.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void FactoryCreateRewrite()
+    {
+        var instance = GuardrailResult.CreateRewrite("test");
+        Assert.NotNull(instance);
+        Assert.True(instance.Allowed);
+    }
+
+    [Fact]
+    public void FactoryDeny()
+    {
+        var instance = GuardrailResult.Deny("test");
+        Assert.NotNull(instance);
+        Assert.False(instance.Allowed);
+    }
+
+    [Fact]
+    public void FactoryAllow()
+    {
+        var instance = GuardrailResult.Allow();
+        Assert.NotNull(instance);
+        Assert.True(instance.Allowed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ImagePartConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ImagePartConversionTests.cs
new file mode 100644
index 00000000..cbca1f7a
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ImagePartConversionTests.cs
@@ -0,0 +1,132 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ImagePartConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+source: "https://example.com/image.png"
+detail: auto
+mediaType: image/png
+
+""";
+
+        var instance = ImagePart.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("https://example.com/image.png", instance.Source);
+        Assert.Equal("auto", instance.Detail);
+        Assert.Equal("image/png", instance.MediaType);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "source": "https://example.com/image.png",
+  "detail": "auto",
+  "mediaType": "image/png"
+}
+""";
+
+        var instance = ImagePart.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("https://example.com/image.png", instance.Source);
+        Assert.Equal("auto", instance.Detail);
+        Assert.Equal("image/png", instance.MediaType);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "source": "https://example.com/image.png",
+  "detail": "auto",
+  "mediaType": "image/png"
+}
+""";
+
+        var original = ImagePart.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ImagePart.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("https://example.com/image.png", reloaded.Source);
+        Assert.Equal("auto", reloaded.Detail);
+        Assert.Equal("image/png", reloaded.MediaType);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+source: "https://example.com/image.png"
+detail: auto
+mediaType: image/png
+
+""";
+
+        var original = ImagePart.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ImagePart.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("https://example.com/image.png", reloaded.Source);
+        Assert.Equal("auto", reloaded.Detail);
+        Assert.Equal("image/png", reloaded.MediaType);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "source": "https://example.com/image.png",
+  "detail": "auto",
+  "mediaType": "image/png"
+}
+""";
+
+        var instance = ImagePart.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+source: "https://example.com/image.png"
+detail: auto
+mediaType: image/png
+
+""";
+
+        var instance = ImagePart.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/McpApprovalModeConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/McpApprovalModeConversionTests.cs
index 18b1d180..a1c356c5 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/McpApprovalModeConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/McpApprovalModeConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
@@ -140,6 +139,7 @@ public void ToYamlProducesValidYaml()
         var parsed = deserializer.Deserialize<object>(yaml);
         Assert.NotNull(parsed);
     }
+
     [Fact]
     public void LoadJsonFromString()
     {
@@ -157,7 +157,7 @@ public void LoadYamlFromString()
         var data = "\"never\"";
         var instance = McpApprovalMode.FromYaml(data);
         Assert.NotNull(instance);
+
         Assert.Equal("never", instance.Kind);
     }
-
 }
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/McpToolConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/McpToolConversionTests.cs
index aa7d1f65..5fec1d09 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/McpToolConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/McpToolConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/MessageConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/MessageConversionTests.cs
new file mode 100644
index 00000000..6a8d39d1
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/MessageConversionTests.cs
@@ -0,0 +1,178 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class MessageConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+role: user
+parts:
+  - kind: text
+    value: Hello!
+metadata:
+  source: user-input
+
+""";
+
+        var instance = Message.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("user", instance.Role);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "role": "user",
+  "parts": [
+    {
+      "kind": "text",
+      "value": "Hello!"
+    }
+  ],
+  "metadata": {
+    "source": "user-input"
+  }
+}
+""";
+
+        var instance = Message.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("user", instance.Role);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "role": "user",
+  "parts": [
+    {
+      "kind": "text",
+      "value": "Hello!"
+    }
+  ],
+  "metadata": {
+    "source": "user-input"
+  }
+}
+""";
+
+        var original = Message.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = Message.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("user", reloaded.Role);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+role: user
+parts:
+  - kind: text
+    value: Hello!
+metadata:
+  source: user-input
+
+""";
+
+        var original = Message.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = Message.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("user", reloaded.Role);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "role": "user",
+  "parts": [
+    {
+      "kind": "text",
+      "value": "Hello!"
+    }
+  ],
+  "metadata": {
+    "source": "user-input"
+  }
+}
+""";
+
+        var instance = Message.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+role: user
+parts:
+  - kind: text
+    value: Hello!
+metadata:
+  source: user-input
+
+""";
+
+        var instance = Message.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void FactoryAssistant()
+    {
+        var instance = Message.Assistant("test");
+        Assert.NotNull(instance);
+        Assert.Equal("assistant", instance.Role);
+    }
+
+    [Fact]
+    public void FactorySystem()
+    {
+        var instance = Message.System("test");
+        Assert.NotNull(instance);
+        Assert.Equal("system", instance.Role);
+    }
+
+    [Fact]
+    public void FactoryUser()
+    {
+        var instance = Message.User("test");
+        Assert.NotNull(instance);
+        Assert.Equal("user", instance.Role);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/MessagesUpdatedPayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/MessagesUpdatedPayloadConversionTests.cs
new file mode 100644
index 00000000..8a059d2c
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/MessagesUpdatedPayloadConversionTests.cs
@@ -0,0 +1,10 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class MessagesUpdatedPayloadConversionTests
+{
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ModelConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ModelConversionTests.cs
index cf7eca2e..8caf5761 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/ModelConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ModelConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
@@ -184,6 +183,7 @@ public void ToYamlProducesValidYaml()
         var parsed = deserializer.Deserialize<object>(yaml);
         Assert.NotNull(parsed);
     }
+
     [Fact]
     public void LoadJsonFromString()
     {
@@ -201,7 +201,7 @@ public void LoadYamlFromString()
         var data = "\"example\"";
         var instance = Model.FromYaml(data);
         Assert.NotNull(instance);
+
         Assert.Equal("example", instance.Id);
     }
-
 }
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ModelInfoConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ModelInfoConversionTests.cs
new file mode 100644
index 00000000..61f89034
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ModelInfoConversionTests.cs
@@ -0,0 +1,193 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ModelInfoConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+id: gpt-4o
+displayName: GPT-4o
+ownedBy: openai
+contextWindow: 128000
+inputModalities:
+  - text
+  - image
+outputModalities:
+  - text
+additionalProperties:
+  supportsStreaming: true
+
+""";
+
+        var instance = ModelInfo.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("gpt-4o", instance.Id);
+        Assert.Equal("GPT-4o", instance.DisplayName);
+        Assert.Equal("openai", instance.OwnedBy);
+        Assert.Equal(128000, instance.ContextWindow);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "id": "gpt-4o",
+  "displayName": "GPT-4o",
+  "ownedBy": "openai",
+  "contextWindow": 128000,
+  "inputModalities": [
+    "text",
+    "image"
+  ],
+  "outputModalities": [
+    "text"
+  ],
+  "additionalProperties": {
+    "supportsStreaming": true
+  }
+}
+""";
+
+        var instance = ModelInfo.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("gpt-4o", instance.Id);
+        Assert.Equal("GPT-4o", instance.DisplayName);
+        Assert.Equal("openai", instance.OwnedBy);
+        Assert.Equal(128000, instance.ContextWindow);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "id": "gpt-4o",
+  "displayName": "GPT-4o",
+  "ownedBy": "openai",
+  "contextWindow": 128000,
+  "inputModalities": [
+    "text",
+    "image"
+  ],
+  "outputModalities": [
+    "text"
+  ],
+  "additionalProperties": {
+    "supportsStreaming": true
+  }
+}
+""";
+
+        var original = ModelInfo.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ModelInfo.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("gpt-4o", reloaded.Id);
+        Assert.Equal("GPT-4o", reloaded.DisplayName);
+        Assert.Equal("openai", reloaded.OwnedBy);
+        Assert.Equal(128000, reloaded.ContextWindow);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+id: gpt-4o
+displayName: GPT-4o
+ownedBy: openai
+contextWindow: 128000
+inputModalities:
+  - text
+  - image
+outputModalities:
+  - text
+additionalProperties:
+  supportsStreaming: true
+
+""";
+
+        var original = ModelInfo.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ModelInfo.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("gpt-4o", reloaded.Id);
+        Assert.Equal("GPT-4o", reloaded.DisplayName);
+        Assert.Equal("openai", reloaded.OwnedBy);
+        Assert.Equal(128000, reloaded.ContextWindow);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "id": "gpt-4o",
+  "displayName": "GPT-4o",
+  "ownedBy": "openai",
+  "contextWindow": 128000,
+  "inputModalities": [
+    "text",
+    "image"
+  ],
+  "outputModalities": [
+    "text"
+  ],
+  "additionalProperties": {
+    "supportsStreaming": true
+  }
+}
+""";
+
+        var instance = ModelInfo.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+id: gpt-4o
+displayName: GPT-4o
+ownedBy: openai
+contextWindow: 128000
+inputModalities:
+  - text
+  - image
+outputModalities:
+  - text
+additionalProperties:
+  supportsStreaming: true
+
+""";
+
+        var instance = ModelInfo.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ModelOptionsConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ModelOptionsConversionTests.cs
index f3a04f5c..dc497430 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/ModelOptionsConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ModelOptionsConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/OAuthConnectionConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/OAuthConnectionConversionTests.cs
index 0481b1dc..de6b3f4f 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/OAuthConnectionConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/OAuthConnectionConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ObjectPropertyConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ObjectPropertyConversionTests.cs
index c86da3fb..c09c7338 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/ObjectPropertyConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ObjectPropertyConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/OpenApiToolConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/OpenApiToolConversionTests.cs
index 442cd4dd..e1678895 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/OpenApiToolConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/OpenApiToolConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ParserConfigConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ParserConfigConversionTests.cs
index 114e4b93..1f2edafe 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/ParserConfigConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ParserConfigConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
@@ -125,6 +124,7 @@ public void ToYamlProducesValidYaml()
         var parsed = deserializer.Deserialize<object>(yaml);
         Assert.NotNull(parsed);
     }
+
     [Fact]
     public void LoadJsonFromString()
     {
@@ -142,7 +142,7 @@ public void LoadYamlFromString()
         var data = "\"example\"";
         var instance = ParserConfig.FromYaml(data);
         Assert.NotNull(instance);
+
         Assert.Equal("example", instance.Kind);
     }
-
 }
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/PromptyConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/PromptyConversionTests.cs
index 6b302841..9b6b2548 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/PromptyConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/PromptyConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/PromptyToolConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/PromptyToolConversionTests.cs
index e6eca0ca..15745977 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/PromptyToolConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/PromptyToolConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/PropertyConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/PropertyConversionTests.cs
index 4abf8d97..0119ddf9 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/PropertyConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/PropertyConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
@@ -187,6 +186,7 @@ public void ToYamlProducesValidYaml()
         var parsed = deserializer.Deserialize<object>(yaml);
         Assert.NotNull(parsed);
     }
+
     [Fact]
     public void LoadJsonFromBoolean()
     {
@@ -207,11 +207,13 @@ public void LoadYamlFromBoolean()
         var data = "false";
         var instance = Property.FromYaml(data);
         Assert.NotNull(instance);
+
         Assert.Equal("boolean", instance.Kind);
         Assert.NotNull(instance.Example);
         Assert.IsType<bool>(instance.Example);
         Assert.False((bool)instance.Example);
     }
+
     [Fact]
     public void LoadJsonFromFloat32()
     {
@@ -232,11 +234,13 @@ public void LoadYamlFromFloat32()
         var data = "3.14";
         var instance = Property.FromYaml(data);
         Assert.NotNull(instance);
+
         Assert.Equal("float", instance.Kind);
         Assert.NotNull(instance.Example);
         Assert.True(instance.Example is float || instance.Example is double || instance.Example is int || instance.Example is long);
         Assert.Equal(3.14, Convert.ToDouble(instance.Example), 5);
     }
+
     [Fact]
     public void LoadJsonFromInteger()
     {
@@ -255,9 +259,11 @@ public void LoadYamlFromInteger()
         var data = "4";
         var instance = Property.FromYaml(data);
         Assert.NotNull(instance);
+
         Assert.Equal("integer", instance.Kind);
         Assert.Equal(4, instance.Example);
     }
+
     [Fact]
     public void LoadJsonFromString()
     {
@@ -276,8 +282,8 @@ public void LoadYamlFromString()
         var data = "\"example\"";
         var instance = Property.FromYaml(data);
         Assert.NotNull(instance);
+
         Assert.Equal("string", instance.Kind);
         Assert.Equal("example", instance.Example);
     }
-
 }
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ReferenceConnectionConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ReferenceConnectionConversionTests.cs
index 18557abd..09c63f41 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/ReferenceConnectionConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ReferenceConnectionConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/RemoteConnectionConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/RemoteConnectionConversionTests.cs
index b1a80558..8468e835 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/RemoteConnectionConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/RemoteConnectionConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/StatusEventPayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/StatusEventPayloadConversionTests.cs
new file mode 100644
index 00000000..1b5ac43e
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/StatusEventPayloadConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class StatusEventPayloadConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+message: Starting iteration 3
+
+""";
+
+        var instance = StatusEventPayload.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("Starting iteration 3", instance.Message);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "message": "Starting iteration 3"
+}
+""";
+
+        var instance = StatusEventPayload.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("Starting iteration 3", instance.Message);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "message": "Starting iteration 3"
+}
+""";
+
+        var original = StatusEventPayload.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = StatusEventPayload.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Starting iteration 3", reloaded.Message);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+message: Starting iteration 3
+
+""";
+
+        var original = StatusEventPayload.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = StatusEventPayload.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Starting iteration 3", reloaded.Message);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "message": "Starting iteration 3"
+}
+""";
+
+        var instance = StatusEventPayload.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+message: Starting iteration 3
+
+""";
+
+        var instance = StatusEventPayload.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/StreamChunkConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/StreamChunkConversionTests.cs
new file mode 100644
index 00000000..16733bb8
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/StreamChunkConversionTests.cs
@@ -0,0 +1,10 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class StreamChunkConversionTests
+{
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/TemplateConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/TemplateConversionTests.cs
index 0cb974eb..695bbc8c 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/TemplateConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/TemplateConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/TextChunkConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/TextChunkConversionTests.cs
new file mode 100644
index 00000000..97c129ad
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/TextChunkConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class TextChunkConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+value: Hello
+
+""";
+
+        var instance = TextChunk.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("Hello", instance.Value);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "value": "Hello"
+}
+""";
+
+        var instance = TextChunk.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("Hello", instance.Value);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "value": "Hello"
+}
+""";
+
+        var original = TextChunk.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = TextChunk.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Hello", reloaded.Value);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+value: Hello
+
+""";
+
+        var original = TextChunk.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = TextChunk.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Hello", reloaded.Value);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "value": "Hello"
+}
+""";
+
+        var instance = TextChunk.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+value: Hello
+
+""";
+
+        var instance = TextChunk.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/TextPartConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/TextPartConversionTests.cs
new file mode 100644
index 00000000..43932a86
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/TextPartConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class TextPartConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+value: Hello, world!
+
+""";
+
+        var instance = TextPart.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("Hello, world!", instance.Value);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "value": "Hello, world!"
+}
+""";
+
+        var instance = TextPart.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("Hello, world!", instance.Value);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "value": "Hello, world!"
+}
+""";
+
+        var original = TextPart.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = TextPart.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Hello, world!", reloaded.Value);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+value: Hello, world!
+
+""";
+
+        var original = TextPart.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = TextPart.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Hello, world!", reloaded.Value);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "value": "Hello, world!"
+}
+""";
+
+        var instance = TextPart.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+value: Hello, world!
+
+""";
+
+        var instance = TextPart.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ThinkingChunkConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ThinkingChunkConversionTests.cs
new file mode 100644
index 00000000..3d2495a8
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ThinkingChunkConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ThinkingChunkConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+value: Let me consider...
+
+""";
+
+        var instance = ThinkingChunk.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("Let me consider...", instance.Value);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "value": "Let me consider..."
+}
+""";
+
+        var instance = ThinkingChunk.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("Let me consider...", instance.Value);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "value": "Let me consider..."
+}
+""";
+
+        var original = ThinkingChunk.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ThinkingChunk.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Let me consider...", reloaded.Value);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+value: Let me consider...
+
+""";
+
+        var original = ThinkingChunk.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ThinkingChunk.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Let me consider...", reloaded.Value);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "value": "Let me consider..."
+}
+""";
+
+        var instance = ThinkingChunk.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+value: Let me consider...
+
+""";
+
+        var instance = ThinkingChunk.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ThinkingEventPayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ThinkingEventPayloadConversionTests.cs
new file mode 100644
index 00000000..3731ba7d
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ThinkingEventPayloadConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ThinkingEventPayloadConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+token: Let me consider...
+
+""";
+
+        var instance = ThinkingEventPayload.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("Let me consider...", instance.Token);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "token": "Let me consider..."
+}
+""";
+
+        var instance = ThinkingEventPayload.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("Let me consider...", instance.Token);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "token": "Let me consider..."
+}
+""";
+
+        var original = ThinkingEventPayload.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ThinkingEventPayload.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Let me consider...", reloaded.Token);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+token: Let me consider...
+
+""";
+
+        var original = ThinkingEventPayload.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ThinkingEventPayload.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Let me consider...", reloaded.Token);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "token": "Let me consider..."
+}
+""";
+
+        var instance = ThinkingEventPayload.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+token: Let me consider...
+
+""";
+
+        var instance = ThinkingEventPayload.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ThreadMarkerConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ThreadMarkerConversionTests.cs
new file mode 100644
index 00000000..04d59ff4
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ThreadMarkerConversionTests.cs
@@ -0,0 +1,122 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ThreadMarkerConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+name: thread
+kind: thread
+
+""";
+
+        var instance = ThreadMarker.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("thread", instance.Name);
+        Assert.Equal("thread", instance.Kind);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "name": "thread",
+  "kind": "thread"
+}
+""";
+
+        var instance = ThreadMarker.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("thread", instance.Name);
+        Assert.Equal("thread", instance.Kind);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "name": "thread",
+  "kind": "thread"
+}
+""";
+
+        var original = ThreadMarker.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ThreadMarker.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("thread", reloaded.Name);
+        Assert.Equal("thread", reloaded.Kind);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+name: thread
+kind: thread
+
+""";
+
+        var original = ThreadMarker.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ThreadMarker.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("thread", reloaded.Name);
+        Assert.Equal("thread", reloaded.Kind);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "name": "thread",
+  "kind": "thread"
+}
+""";
+
+        var instance = ThreadMarker.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+name: thread
+kind: thread
+
+""";
+
+        var instance = ThreadMarker.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/TokenEventPayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/TokenEventPayloadConversionTests.cs
new file mode 100644
index 00000000..cff968d0
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/TokenEventPayloadConversionTests.cs
@@ -0,0 +1,112 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class TokenEventPayloadConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+token: Hello
+
+""";
+
+        var instance = TokenEventPayload.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("Hello", instance.Token);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "token": "Hello"
+}
+""";
+
+        var instance = TokenEventPayload.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("Hello", instance.Token);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "token": "Hello"
+}
+""";
+
+        var original = TokenEventPayload.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = TokenEventPayload.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Hello", reloaded.Token);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+token: Hello
+
+""";
+
+        var original = TokenEventPayload.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = TokenEventPayload.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("Hello", reloaded.Token);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "token": "Hello"
+}
+""";
+
+        var instance = TokenEventPayload.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+token: Hello
+
+""";
+
+        var instance = TokenEventPayload.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/TokenUsageConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/TokenUsageConversionTests.cs
new file mode 100644
index 00000000..13605019
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/TokenUsageConversionTests.cs
@@ -0,0 +1,132 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class TokenUsageConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+promptTokens: 150
+completionTokens: 42
+totalTokens: 192
+
+""";
+
+        var instance = TokenUsage.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal(150, instance.PromptTokens);
+        Assert.Equal(42, instance.CompletionTokens);
+        Assert.Equal(192, instance.TotalTokens);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "promptTokens": 150,
+  "completionTokens": 42,
+  "totalTokens": 192
+}
+""";
+
+        var instance = TokenUsage.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal(150, instance.PromptTokens);
+        Assert.Equal(42, instance.CompletionTokens);
+        Assert.Equal(192, instance.TotalTokens);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "promptTokens": 150,
+  "completionTokens": 42,
+  "totalTokens": 192
+}
+""";
+
+        var original = TokenUsage.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = TokenUsage.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal(150, reloaded.PromptTokens);
+        Assert.Equal(42, reloaded.CompletionTokens);
+        Assert.Equal(192, reloaded.TotalTokens);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+promptTokens: 150
+completionTokens: 42
+totalTokens: 192
+
+""";
+
+        var original = TokenUsage.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = TokenUsage.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal(150, reloaded.PromptTokens);
+        Assert.Equal(42, reloaded.CompletionTokens);
+        Assert.Equal(192, reloaded.TotalTokens);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "promptTokens": 150,
+  "completionTokens": 42,
+  "totalTokens": 192
+}
+""";
+
+        var instance = TokenUsage.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+promptTokens: 150
+completionTokens: 42
+totalTokens: 192
+
+""";
+
+        var instance = TokenUsage.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ToolCallConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ToolCallConversionTests.cs
new file mode 100644
index 00000000..d21b2191
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ToolCallConversionTests.cs
@@ -0,0 +1,132 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ToolCallConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+id: call_abc123
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+""";
+
+        var instance = ToolCall.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("call_abc123", instance.Id);
+        Assert.Equal("get_weather", instance.Name);
+        Assert.Equal(@"{""city"": ""Paris""}".Replace("\r\n", "\n"), instance.Arguments);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "id": "call_abc123",
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+""";
+
+        var instance = ToolCall.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("call_abc123", instance.Id);
+        Assert.Equal("get_weather", instance.Name);
+        Assert.Equal(@"{""city"": ""Paris""}".Replace("\r\n", "\n"), instance.Arguments);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "id": "call_abc123",
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+""";
+
+        var original = ToolCall.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ToolCall.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("call_abc123", reloaded.Id);
+        Assert.Equal("get_weather", reloaded.Name);
+        Assert.Equal(@"{""city"": ""Paris""}".Replace("\r\n", "\n"), reloaded.Arguments);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+id: call_abc123
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+""";
+
+        var original = ToolCall.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ToolCall.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("call_abc123", reloaded.Id);
+        Assert.Equal("get_weather", reloaded.Name);
+        Assert.Equal(@"{""city"": ""Paris""}".Replace("\r\n", "\n"), reloaded.Arguments);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "id": "call_abc123",
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+""";
+
+        var instance = ToolCall.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+id: call_abc123
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+""";
+
+        var instance = ToolCall.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ToolCallStartPayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ToolCallStartPayloadConversionTests.cs
new file mode 100644
index 00000000..7c907643
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ToolCallStartPayloadConversionTests.cs
@@ -0,0 +1,122 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ToolCallStartPayloadConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+""";
+
+        var instance = ToolCallStartPayload.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("get_weather", instance.Name);
+        Assert.Equal(@"{""city"": ""Paris""}".Replace("\r\n", "\n"), instance.Arguments);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+""";
+
+        var instance = ToolCallStartPayload.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("get_weather", instance.Name);
+        Assert.Equal(@"{""city"": ""Paris""}".Replace("\r\n", "\n"), instance.Arguments);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+""";
+
+        var original = ToolCallStartPayload.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ToolCallStartPayload.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("get_weather", reloaded.Name);
+        Assert.Equal(@"{""city"": ""Paris""}".Replace("\r\n", "\n"), reloaded.Arguments);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+""";
+
+        var original = ToolCallStartPayload.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ToolCallStartPayload.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("get_weather", reloaded.Name);
+        Assert.Equal(@"{""city"": ""Paris""}".Replace("\r\n", "\n"), reloaded.Arguments);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+""";
+
+        var instance = ToolCallStartPayload.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+""";
+
+        var instance = ToolCallStartPayload.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ToolChunkConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ToolChunkConversionTests.cs
new file mode 100644
index 00000000..ef3b3c8c
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ToolChunkConversionTests.cs
@@ -0,0 +1,129 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ToolChunkConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+toolCall:
+  id: call_abc123
+  name: get_weather
+  arguments: "{\"city\": \"Paris\"}"
+
+""";
+
+        var instance = ToolChunk.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "toolCall": {
+    "id": "call_abc123",
+    "name": "get_weather",
+    "arguments": "{\"city\": \"Paris\"}"
+  }
+}
+""";
+
+        var instance = ToolChunk.FromJson(jsonData);
+        Assert.NotNull(instance);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "toolCall": {
+    "id": "call_abc123",
+    "name": "get_weather",
+    "arguments": "{\"city\": \"Paris\"}"
+  }
+}
+""";
+
+        var original = ToolChunk.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ToolChunk.FromJson(json);
+        Assert.NotNull(reloaded);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+toolCall:
+  id: call_abc123
+  name: get_weather
+  arguments: "{\"city\": \"Paris\"}"
+
+""";
+
+        var original = ToolChunk.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ToolChunk.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "toolCall": {
+    "id": "call_abc123",
+    "name": "get_weather",
+    "arguments": "{\"city\": \"Paris\"}"
+  }
+}
+""";
+
+        var instance = ToolChunk.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+toolCall:
+  id: call_abc123
+  name: get_weather
+  arguments: "{\"city\": \"Paris\"}"
+
+""";
+
+        var instance = ToolChunk.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ToolContextConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ToolContextConversionTests.cs
new file mode 100644
index 00000000..beee477a
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ToolContextConversionTests.cs
@@ -0,0 +1,117 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ToolContextConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+metadata:
+  userId: user-123
+
+""";
+
+        var instance = ToolContext.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "metadata": {
+    "userId": "user-123"
+  }
+}
+""";
+
+        var instance = ToolContext.FromJson(jsonData);
+        Assert.NotNull(instance);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "metadata": {
+    "userId": "user-123"
+  }
+}
+""";
+
+        var original = ToolContext.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ToolContext.FromJson(json);
+        Assert.NotNull(reloaded);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+metadata:
+  userId: user-123
+
+""";
+
+        var original = ToolContext.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ToolContext.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "metadata": {
+    "userId": "user-123"
+  }
+}
+""";
+
+        var instance = ToolContext.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+metadata:
+  userId: user-123
+
+""";
+
+        var instance = ToolContext.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ToolConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ToolConversionTests.cs
index 69117ff1..3ffb95e5 100644
--- a/runtime/csharp/Prompty.Core.Tests/Model/ToolConversionTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ToolConversionTests.cs
@@ -1,4 +1,3 @@
-
 using Xunit;
 
 #pragma warning disable IDE0130
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ToolDispatchResultConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ToolDispatchResultConversionTests.cs
new file mode 100644
index 00000000..f442e5d8
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ToolDispatchResultConversionTests.cs
@@ -0,0 +1,158 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ToolDispatchResultConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+toolCallId: call_abc123
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+""";
+
+        var instance = ToolDispatchResult.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("call_abc123", instance.ToolCallId);
+        Assert.Equal("get_weather", instance.Name);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "toolCallId": "call_abc123",
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+""";
+
+        var instance = ToolDispatchResult.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("call_abc123", instance.ToolCallId);
+        Assert.Equal("get_weather", instance.Name);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "toolCallId": "call_abc123",
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+""";
+
+        var original = ToolDispatchResult.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ToolDispatchResult.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("call_abc123", reloaded.ToolCallId);
+        Assert.Equal("get_weather", reloaded.Name);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+toolCallId: call_abc123
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+""";
+
+        var original = ToolDispatchResult.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ToolDispatchResult.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("call_abc123", reloaded.ToolCallId);
+        Assert.Equal("get_weather", reloaded.Name);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "toolCallId": "call_abc123",
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+""";
+
+        var instance = ToolDispatchResult.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+toolCallId: call_abc123
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+""";
+
+        var instance = ToolDispatchResult.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ToolResultConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ToolResultConversionTests.cs
new file mode 100644
index 00000000..ab7b0219
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ToolResultConversionTests.cs
@@ -0,0 +1,136 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ToolResultConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+parts:
+  - kind: text
+    value: 72°F and sunny
+
+""";
+
+        var instance = ToolResult.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "parts": [
+    {
+      "kind": "text",
+      "value": "72°F and sunny"
+    }
+  ]
+}
+""";
+
+        var instance = ToolResult.FromJson(jsonData);
+        Assert.NotNull(instance);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "parts": [
+    {
+      "kind": "text",
+      "value": "72°F and sunny"
+    }
+  ]
+}
+""";
+
+        var original = ToolResult.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ToolResult.FromJson(json);
+        Assert.NotNull(reloaded);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+parts:
+  - kind: text
+    value: 72°F and sunny
+
+""";
+
+        var original = ToolResult.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ToolResult.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "parts": [
+    {
+      "kind": "text",
+      "value": "72°F and sunny"
+    }
+  ]
+}
+""";
+
+        var instance = ToolResult.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+parts:
+  - kind: text
+    value: 72°F and sunny
+
+""";
+
+        var instance = ToolResult.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void FactoryText()
+    {
+        var instance = ToolResult.CreateText("test");
+        Assert.NotNull(instance);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/ToolResultPayloadConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/ToolResultPayloadConversionTests.cs
new file mode 100644
index 00000000..adf10d5e
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/ToolResultPayloadConversionTests.cs
@@ -0,0 +1,148 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class ToolResultPayloadConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+""";
+
+        var instance = ToolResultPayload.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal("get_weather", instance.Name);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+""";
+
+        var instance = ToolResultPayload.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal("get_weather", instance.Name);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+""";
+
+        var original = ToolResultPayload.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = ToolResultPayload.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal("get_weather", reloaded.Name);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+""";
+
+        var original = ToolResultPayload.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = ToolResultPayload.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal("get_weather", reloaded.Name);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+""";
+
+        var instance = ToolResultPayload.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+""";
+
+        var instance = ToolResultPayload.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/Model/TurnOptionsConversionTests.cs b/runtime/csharp/Prompty.Core.Tests/Model/TurnOptionsConversionTests.cs
new file mode 100644
index 00000000..901a5bc2
--- /dev/null
+++ b/runtime/csharp/Prompty.Core.Tests/Model/TurnOptionsConversionTests.cs
@@ -0,0 +1,177 @@
+using Xunit;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+
+public class TurnOptionsConversionTests
+{
+    [Fact]
+    public void LoadYamlInput()
+    {
+        string yamlData = """
+maxIterations: 10
+maxLlmRetries: 3
+contextBudget: 100000
+parallelToolCalls: true
+raw: false
+turn: 1
+compaction:
+  strategy: summarize
+
+""";
+
+        var instance = TurnOptions.FromYaml(yamlData);
+
+        Assert.NotNull(instance);
+        Assert.Equal(10, instance.MaxIterations);
+        Assert.Equal(3, instance.MaxLlmRetries);
+        Assert.Equal(100000, instance.ContextBudget);
+        Assert.True(instance.ParallelToolCalls);
+        Assert.False(instance.Raw);
+        Assert.Equal(1, instance.Turn);
+    }
+
+    [Fact]
+    public void LoadJsonInput()
+    {
+        string jsonData = """
+{
+  "maxIterations": 10,
+  "maxLlmRetries": 3,
+  "contextBudget": 100000,
+  "parallelToolCalls": true,
+  "raw": false,
+  "turn": 1,
+  "compaction": {
+    "strategy": "summarize"
+  }
+}
+""";
+
+        var instance = TurnOptions.FromJson(jsonData);
+        Assert.NotNull(instance);
+        Assert.Equal(10, instance.MaxIterations);
+        Assert.Equal(3, instance.MaxLlmRetries);
+        Assert.Equal(100000, instance.ContextBudget);
+        Assert.True(instance.ParallelToolCalls);
+        Assert.False(instance.Raw);
+        Assert.Equal(1, instance.Turn);
+    }
+
+    [Fact]
+    public void RoundtripJson()
+    {
+        // Test that FromJson -> ToJson -> FromJson produces equivalent data
+        string jsonData = """
+{
+  "maxIterations": 10,
+  "maxLlmRetries": 3,
+  "contextBudget": 100000,
+  "parallelToolCalls": true,
+  "raw": false,
+  "turn": 1,
+  "compaction": {
+    "strategy": "summarize"
+  }
+}
+""";
+
+        var original = TurnOptions.FromJson(jsonData);
+        Assert.NotNull(original);
+
+        var json = original.ToJson();
+        Assert.False(string.IsNullOrEmpty(json));
+
+        var reloaded = TurnOptions.FromJson(json);
+        Assert.NotNull(reloaded);
+        Assert.Equal(10, reloaded.MaxIterations);
+        Assert.Equal(3, reloaded.MaxLlmRetries);
+        Assert.Equal(100000, reloaded.ContextBudget);
+        Assert.True(reloaded.ParallelToolCalls);
+        Assert.False(reloaded.Raw);
+        Assert.Equal(1, reloaded.Turn);
+    }
+
+    [Fact]
+    public void RoundtripYaml()
+    {
+        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
+        string yamlData = """
+maxIterations: 10
+maxLlmRetries: 3
+contextBudget: 100000
+parallelToolCalls: true
+raw: false
+turn: 1
+compaction:
+  strategy: summarize
+
+""";
+
+        var original = TurnOptions.FromYaml(yamlData);
+        Assert.NotNull(original);
+
+        var yaml = original.ToYaml();
+        Assert.False(string.IsNullOrEmpty(yaml));
+
+        var reloaded = TurnOptions.FromYaml(yaml);
+        Assert.NotNull(reloaded);
+        Assert.Equal(10, reloaded.MaxIterations);
+        Assert.Equal(3, reloaded.MaxLlmRetries);
+        Assert.Equal(100000, reloaded.ContextBudget);
+        Assert.True(reloaded.ParallelToolCalls);
+        Assert.False(reloaded.Raw);
+        Assert.Equal(1, reloaded.Turn);
+    }
+
+    [Fact]
+    public void ToJsonProducesValidJson()
+    {
+        string jsonData = """
+{
+  "maxIterations": 10,
+  "maxLlmRetries": 3,
+  "contextBudget": 100000,
+  "parallelToolCalls": true,
+  "raw": false,
+  "turn": 1,
+  "compaction": {
+    "strategy": "summarize"
+  }
+}
+""";
+
+        var instance = TurnOptions.FromJson(jsonData);
+        var json = instance.ToJson();
+
+        // Verify it's valid JSON by parsing it
+        var parsed = System.Text.Json.JsonDocument.Parse(json);
+        Assert.NotNull(parsed);
+    }
+
+    [Fact]
+    public void ToYamlProducesValidYaml()
+    {
+        string yamlData = """
+maxIterations: 10
+maxLlmRetries: 3
+contextBudget: 100000
+parallelToolCalls: true
+raw: false
+turn: 1
+compaction:
+  strategy: summarize
+
+""";
+
+        var instance = TurnOptions.FromYaml(yamlData);
+        var yaml = instance.ToYaml();
+
+        // Verify it's valid YAML by parsing it
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
+        var parsed = deserializer.Deserialize<object>(yaml);
+        Assert.NotNull(parsed);
+    }
+}
diff --git a/runtime/csharp/Prompty.Core.Tests/ParserTests.cs b/runtime/csharp/Prompty.Core.Tests/ParserTests.cs
index 13cdc0bb..3df12973 100644
--- a/runtime/csharp/Prompty.Core.Tests/ParserTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/ParserTests.cs
@@ -15,7 +15,7 @@ public class PromptyChatParserTests
     [Fact]
     public async Task Parse_SingleSystemRole()
     {
-        var messages = await _parser.ParseAsync(CreateAgent(), "system:\nYou are helpful.");
+        var messages = await _parser.ParseAsync(CreateAgent(), "system:\nYou are helpful.", null);
         Assert.Single(messages);
         Assert.Equal(Roles.System, messages[0].Role);
         Assert.Equal("You are helpful.", messages[0].Text);
@@ -25,7 +25,7 @@ public async Task Parse_SingleSystemRole()
     public async Task Parse_MultipleRoles()
     {
         var text = "system:\nYou are helpful.\n\nuser:\nHello\n\nassistant:\nHi there!";
-        var messages = await _parser.ParseAsync(CreateAgent(), text);
+        var messages = await _parser.ParseAsync(CreateAgent(), text, null);
         Assert.Equal(3, messages.Count);
         Assert.Equal(Roles.System, messages[0].Role);
         Assert.Equal(Roles.User, messages[1].Role);
@@ -35,7 +35,7 @@ public async Task Parse_MultipleRoles()
     [Fact]
     public async Task Parse_DeveloperRole()
     {
-        var messages = await _parser.ParseAsync(CreateAgent(), "developer:\nInstructions here.");
+        var messages = await _parser.ParseAsync(CreateAgent(), "developer:\nInstructions here.", null);
         Assert.Single(messages);
         Assert.Equal(Roles.Developer, messages[0].Role);
     }
@@ -43,7 +43,7 @@ public async Task Parse_DeveloperRole()
     [Fact]
     public async Task Parse_ToolRole()
     {
-        var messages = await _parser.ParseAsync(CreateAgent(), "tool:\nTool response");
+        var messages = await _parser.ParseAsync(CreateAgent(), "tool:\nTool response", null);
         Assert.Single(messages);
         Assert.Equal(Roles.Tool, messages[0].Role);
     }
@@ -56,7 +56,7 @@ public async Task Parse_ToolRole()
     public async Task Parse_TrimsLeadingTrailingBlankLines()
     {
         var text = "system:\n\n\nHello\n\n";
-        var messages = await _parser.ParseAsync(CreateAgent(), text);
+        var messages = await _parser.ParseAsync(CreateAgent(), text, null);
         Assert.Equal("Hello", messages[0].Text);
     }
 
@@ -64,7 +64,7 @@ public async Task Parse_TrimsLeadingTrailingBlankLines()
     public async Task Parse_PreservesInternalWhitespace()
     {
         var text = "system:\nLine 1\n\nLine 3";
-        var messages = await _parser.ParseAsync(CreateAgent(), text);
+        var messages = await _parser.ParseAsync(CreateAgent(), text, null);
         Assert.Contains("Line 1\n\nLine 3", messages[0].Text);
     }
 
@@ -72,7 +72,7 @@ public async Task Parse_PreservesInternalWhitespace()
     public async Task Parse_MultilineContent()
     {
         var text = "system:\nLine 1\nLine 2\nLine 3";
-        var messages = await _parser.ParseAsync(CreateAgent(), text);
+        var messages = await _parser.ParseAsync(CreateAgent(), text, null);
         Assert.Contains("Line 1", messages[0].Text);
         Assert.Contains("Line 3", messages[0].Text);
     }
@@ -84,7 +84,7 @@ public async Task Parse_MultilineContent()
     [Fact]
     public async Task Parse_NoRoleMarkers_DefaultsToSystem()
     {
-        var messages = await _parser.ParseAsync(CreateAgent(), "Just some text");
+        var messages = await _parser.ParseAsync(CreateAgent(), "Just some text", null);
         Assert.Single(messages);
         Assert.Equal(Roles.System, messages[0].Role);
         Assert.Equal("Just some text", messages[0].Text);
@@ -93,14 +93,14 @@ public async Task Parse_NoRoleMarkers_DefaultsToSystem()
     [Fact]
     public async Task Parse_EmptyInput_ReturnsNoMessages()
     {
-        var messages = await _parser.ParseAsync(CreateAgent(), "");
+        var messages = await _parser.ParseAsync(CreateAgent(), "", null);
         Assert.Empty(messages);
     }
 
     [Fact]
     public async Task Parse_WhitespaceOnly_ReturnsNoMessages()
     {
-        var messages = await _parser.ParseAsync(CreateAgent(), "   \n\n  ");
+        var messages = await _parser.ParseAsync(CreateAgent(), "   \n\n  ", null);
         Assert.Empty(messages);
     }
 
@@ -112,7 +112,7 @@ public async Task Parse_WhitespaceOnly_ReturnsNoMessages()
     public async Task Parse_RoleWithAttributes()
     {
         var text = "tool[tool_call_id=\"call_123\", name=\"get_weather\"]:\nResult here";
-        var messages = await _parser.ParseAsync(CreateAgent(), text);
+        var messages = await _parser.ParseAsync(CreateAgent(), text, null);
         Assert.Single(messages);
         Assert.Equal(Roles.Tool, messages[0].Role);
         Assert.Equal("call_123", messages[0].Metadata["tool_call_id"]);
@@ -154,10 +154,10 @@ public async Task PreRender_Then_Parse_ValidatesNonce()
         var (sanitized, _) = parser.PreRender(template);
 
         // Parsing the pre-rendered template should work (nonce matches)
-        var messages = await parser.ParseAsync(CreateAgent(), sanitized);
+        var messages = await parser.ParseAsync(CreateAgent(), sanitized, null);
         Assert.Equal(2, messages.Count);
         // Nonce should NOT be in metadata
-        Assert.False(messages[0].Metadata.ContainsKey("nonce"));
+        Assert.False(messages[0].Metadata?.ContainsKey("nonce") ?? false);
     }
 
     // -----------------------------------------------------------------------
@@ -170,7 +170,7 @@ public async Task Parse_ThreadNonce_InContent()
         // Thread nonces appear in rendered text; parser should preserve them as-is
         // (thread expansion happens in pipeline, not parser)
         var text = "system:\nYou are helpful.\n__PROMPTY_THREAD_abcd1234_conversation__\nuser:\nHello";
-        var messages = await _parser.ParseAsync(CreateAgent(), text);
+        var messages = await _parser.ParseAsync(CreateAgent(), text, null);
         Assert.Equal(2, messages.Count);
         Assert.Contains("__PROMPTY_THREAD_abcd1234_conversation__", messages[0].Text);
     }
diff --git a/runtime/csharp/Prompty.Core.Tests/PipelineTests.cs b/runtime/csharp/Prompty.Core.Tests/PipelineTests.cs
index 3b90abd4..cda1daa1 100644
--- a/runtime/csharp/Prompty.Core.Tests/PipelineTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/PipelineTests.cs
@@ -323,7 +323,7 @@ public async Task RenderAsync_UsesFormatKind()
     public async Task ParseAsync_UsesParserKind()
     {
         var agent = CreateAgent();
-        var messages = await Pipeline.ParseAsync(agent, "system:\nHello");
+        var messages = await Pipeline.ParseAsync(agent, "system:\nHello", null);
         Assert.Single(messages); // MockParser returns 1 message
     }
 
@@ -595,7 +595,7 @@ public Task<string> RenderAsync(Prompty agent, string template, Dictionary<strin
 
 internal class MockParser : IParser
 {
-    public Task<List<Message>> ParseAsync(Prompty agent, string rendered)
+    public Task<List<Message>> ParseAsync(Prompty agent, string rendered, Dictionary<string, object?>? context)
         => Task.FromResult<List<Message>>([new Message { Role = Roles.System, Parts = [new TextPart { Value = rendered }] }]);
 }
 
@@ -608,10 +608,10 @@ public List<Message> FormatToolMessages(object rawResponse, List<ToolCall> toolC
     {
         var messages = new List<Message>
         {
-            new() { Role = Roles.Assistant, Parts = [], Metadata = new() { ["tool_calls"] = toolCalls } },
+            new() { Role = Roles.Assistant, Parts = [], Metadata = new Dictionary<string, object> { ["tool_calls"] = toolCalls } },
         };
         for (var i = 0; i < toolCalls.Count; i++)
-            messages.Add(new() { Role = Roles.Tool, Parts = [new TextPart { Value = toolResults[i] }], Metadata = new() { ["tool_call_id"] = toolCalls[i].Id } });
+            messages.Add(new() { Role = Roles.Tool, Parts = [new TextPart { Value = toolResults[i] }], Metadata = new Dictionary<string, object> { ["tool_call_id"] = toolCalls[i].Id } });
         return messages;
     }
 }
@@ -643,10 +643,10 @@ public List<Message> FormatToolMessages(object rawResponse, List<ToolCall> toolC
     {
         var messages = new List<Message>
         {
-            new() { Role = Roles.Assistant, Parts = [], Metadata = new() { ["tool_calls"] = toolCalls } },
+            new() { Role = Roles.Assistant, Parts = [], Metadata = new Dictionary<string, object> { ["tool_calls"] = toolCalls } },
         };
         for (var i = 0; i < toolCalls.Count; i++)
-            messages.Add(new() { Role = Roles.Tool, Parts = [new TextPart { Value = toolResults[i] }], Metadata = new() { ["tool_call_id"] = toolCalls[i].Id } });
+            messages.Add(new() { Role = Roles.Tool, Parts = [new TextPart { Value = toolResults[i] }], Metadata = new Dictionary<string, object> { ["tool_call_id"] = toolCalls[i].Id } });
         return messages;
     }
 }
diff --git a/runtime/csharp/Prompty.Core.Tests/ResilienceTests.cs b/runtime/csharp/Prompty.Core.Tests/ResilienceTests.cs
index eb498e89..769c34f3 100644
--- a/runtime/csharp/Prompty.Core.Tests/ResilienceTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/ResilienceTests.cs
@@ -73,7 +73,7 @@ public Task<string> RenderAsync(Prompty agent, string template, Dictionary<strin
 /// <summary>A passthrough parser for resilience tests.</summary>
 file class PassthroughParser : IParser
 {
-    public Task<List<Message>> ParseAsync(Prompty agent, string rendered)
+    public Task<List<Message>> ParseAsync(Prompty agent, string rendered, Dictionary<string, object?>? context)
         => Task.FromResult(new List<Message>
         {
             new() { Role = Roles.User, Parts = [new TextPart { Value = rendered }] }
diff --git a/runtime/csharp/Prompty.Core.Tests/SpecVectorTests.cs b/runtime/csharp/Prompty.Core.Tests/SpecVectorTests.cs
index e6b6590b..21a1e916 100644
--- a/runtime/csharp/Prompty.Core.Tests/SpecVectorTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/SpecVectorTests.cs
@@ -151,7 +151,7 @@ public async Task ParseVectors_AllPass()
 
             try
             {
-                var messages = await parser.ParseAsync(agent, rendered);
+                var messages = await parser.ParseAsync(agent, rendered, null);
                 var errors = CompareMessages(messages, expectedMessages);
 
                 if (errors.Count > 0)
diff --git a/runtime/csharp/Prompty.Core.Tests/StructuredOutputPipelineTests.cs b/runtime/csharp/Prompty.Core.Tests/StructuredOutputPipelineTests.cs
index fab3f8e4..7f2d3333 100644
--- a/runtime/csharp/Prompty.Core.Tests/StructuredOutputPipelineTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/StructuredOutputPipelineTests.cs
@@ -247,7 +247,7 @@ public Task<string> RenderAsync(Prompty agent, string template, Dictionary<strin
 /// </summary>
 internal class SingleMessageParser : IParser
 {
-    public Task<List<Message>> ParseAsync(Prompty agent, string rendered)
+    public Task<List<Message>> ParseAsync(Prompty agent, string rendered, Dictionary<string, object?>? context)
         => Task.FromResult<List<Message>>(
             [new Message { Role = Roles.User, Parts = [new TextPart { Value = rendered }] }]);
 }
@@ -265,7 +265,7 @@ public Task<object> ExecuteAsync(Prompty agent, List<Message> messages)
         => Task.FromResult<object>(_rawJson);
 
     public List<Message> FormatToolMessages(object rawResponse, List<ToolCall> toolCalls, List<string> toolResults, string? textContent = null)
-        => [];
+        => new List<Message>();
 }
 
 /// <summary>
diff --git a/runtime/csharp/Prompty.Core.Tests/TracingTests.cs b/runtime/csharp/Prompty.Core.Tests/TracingTests.cs
index ffe611d0..e50d509b 100644
--- a/runtime/csharp/Prompty.Core.Tests/TracingTests.cs
+++ b/runtime/csharp/Prompty.Core.Tests/TracingTests.cs
@@ -571,7 +571,7 @@ public Task<string> RenderAsync(Prompty agent, string template, Dictionary<strin
 
     private class PassthroughParser : IParser
     {
-        public Task<List<Message>> ParseAsync(Prompty agent, string rendered)
+        public Task<List<Message>> ParseAsync(Prompty agent, string rendered, Dictionary<string, object?>? context)
             => Task.FromResult<List<Message>>([new() { Role = Roles.User, Parts = [new TextPart { Value = rendered }] }]);
     }
 
diff --git a/runtime/csharp/Prompty.Core/ContextWindow.cs b/runtime/csharp/Prompty.Core/ContextWindow.cs
index 250fc6f7..bdba6ef5 100644
--- a/runtime/csharp/Prompty.Core/ContextWindow.cs
+++ b/runtime/csharp/Prompty.Core/ContextWindow.cs
@@ -19,7 +19,7 @@ public static int EstimateChars(List<Message> messages)
                 else
                     total += 200;
             }
-            if (msg.Metadata.TryGetValue("tool_calls", out var tc) && tc is not null)
+            if (msg.Metadata is not null && msg.Metadata.TryGetValue("tool_calls", out var tc) && tc is not null)
                 total += System.Text.Json.JsonSerializer.Serialize(tc).Length;
         }
         return total;
@@ -36,7 +36,7 @@ public static string SummarizeDropped(List<Message> messages)
                 lines.Add($"User asked: {Truncate(msgText)}");
             else if (msg.Role == "assistant")
             {
-                if (msg.Metadata.TryGetValue("tool_calls", out var toolCalls) && toolCalls is System.Collections.IEnumerable tcList)
+                if (msg.Metadata is not null && msg.Metadata.TryGetValue("tool_calls", out var toolCalls) && toolCalls is System.Collections.IEnumerable tcList)
                 {
                     var names = new List<string>();
                     foreach (var tc in tcList)
@@ -128,7 +128,7 @@ public static string FormatDroppedMessages(List<Message> messages)
         var lines = new List<string>();
         foreach (var msg in messages)
         {
-            if (msg.Metadata.TryGetValue("tool_calls", out var toolCalls) && toolCalls is System.Collections.IEnumerable tcList)
+            if (msg.Metadata is not null && msg.Metadata.TryGetValue("tool_calls", out var toolCalls) && toolCalls is System.Collections.IEnumerable tcList)
             {
                 foreach (var tc in tcList)
                 {
diff --git a/runtime/csharp/Prompty.Core/Guardrails.cs b/runtime/csharp/Prompty.Core/Guardrails.cs
index 23f3d792..d9d2319a 100644
--- a/runtime/csharp/Prompty.Core/Guardrails.cs
+++ b/runtime/csharp/Prompty.Core/Guardrails.cs
@@ -2,9 +2,6 @@
 
 namespace Prompty.Core;
 
-/// <summary>§13.4 Result of a guardrail check.</summary>
-public record GuardrailResult(bool Allowed, string? Reason = null, object? Rewrite = null);
-
 /// <summary>Error thrown when a guardrail denies the operation.</summary>
 public class GuardrailError : Exception
 {
diff --git a/runtime/csharp/Prompty.Core/IPreRenderable.cs b/runtime/csharp/Prompty.Core/IPreRenderable.cs
new file mode 100644
index 00000000..1dd994b1
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/IPreRenderable.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+namespace Prompty.Core;
+
+/// <summary>
+/// Optional interface for parsers that can sanitize templates before rendering.
+/// When implemented, the pipeline calls PreRender first to get a cleaned template
+/// and context dict, then renders, then parses with that context.
+/// </summary>
+public interface IPreRenderable
+{
+    (string template, Dictionary<string, object?> context) PreRender(string template);
+}
diff --git a/runtime/csharp/Prompty.Core/Interfaces.cs b/runtime/csharp/Prompty.Core/Interfaces.cs
deleted file mode 100644
index fd2efd3b..00000000
--- a/runtime/csharp/Prompty.Core/Interfaces.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-namespace Prompty.Core;
-
-/// <summary>
-/// Renders a PromptAgent's instructions template with input values.
-/// Registered by template format kind (e.g., "jinja2", "mustache").
-/// </summary>
-public interface IRenderer
-{
-    Task<string> RenderAsync(Prompty agent, string template, Dictionary<string, object?> inputs);
-}
-
-/// <summary>
-/// Parses rendered text into a list of Messages.
-/// Registered by parser kind (e.g., "prompty").
-/// </summary>
-public interface IParser
-{
-    Task<List<Message>> ParseAsync(Prompty agent, string rendered);
-}
-
-/// <summary>
-/// Optional interface for parsers that can sanitize templates before rendering.
-/// When implemented, the pipeline calls PreRender first to get a cleaned template
-/// and context dict, then renders, then parses with that context.
-/// </summary>
-public interface IPreRenderable
-{
-    (string template, Dictionary<string, object?> context) PreRender(string template);
-}
-
-/// <summary>
-/// Executes an LLM call with prepared messages.
-/// Registered by provider name (e.g., "openai", "foundry", "anthropic").
-/// </summary>
-public interface IExecutor
-{
-    Task<object> ExecuteAsync(Prompty agent, List<Message> messages);
-
-    /// <summary>
-    /// Formats the assistant tool-call response and dispatched tool results into
-    /// messages for the next agent loop iteration. Each provider implements this
-    /// to match its API's expected wire format, keeping the pipeline provider-agnostic.
-    /// </summary>
-    /// <param name="rawResponse">Original LLM response (for content block preservation).</param>
-    /// <param name="toolCalls">Tool calls extracted by the processor.</param>
-    /// <param name="toolResults">Results from dispatching each tool call, parallel to toolCalls.</param>
-    /// <param name="textContent">Any non-tool text content from the response.</param>
-    List<Message> FormatToolMessages(
-        object rawResponse,
-        List<ToolCall> toolCalls,
-        List<string> toolResults,
-        string? textContent = null);
-}
-
-/// <summary>
-/// Post-processes raw LLM responses into a final result.
-/// Registered by provider name (e.g., "openai", "foundry", "anthropic").
-/// </summary>
-public interface IProcessor
-{
-    Task<object> ProcessAsync(Prompty agent, object response);
-}
diff --git a/runtime/csharp/Prompty.Core/Model/AnonymousConnection.cs b/runtime/csharp/Prompty.Core/Model/AnonymousConnection.cs
index ac41b2f0..67da5fec 100644
--- a/runtime/csharp/Prompty.Core/Model/AnonymousConnection.cs
+++ b/runtime/csharp/Prompty.Core/Model/AnonymousConnection.cs
@@ -7,9 +7,8 @@ namespace Prompty.Core;
 #pragma warning restore IDE0130
 
 /// <summary>
-/// 
 /// </summary>
-public class AnonymousConnection : Connection
+public partial class AnonymousConnection : Connection
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -36,6 +35,7 @@ public AnonymousConnection()
     public string Endpoint { get; set; } = string.Empty;
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -74,7 +74,6 @@ public AnonymousConnection()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -97,15 +96,10 @@ public AnonymousConnection()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Endpoint is not null)
-        {
-            result["endpoint"] = obj.Endpoint;
-        }
+
+        result["endpoint"] = obj.Endpoint;
 
 
         return result;
diff --git a/runtime/csharp/Prompty.Core/Model/ApiKeyConnection.cs b/runtime/csharp/Prompty.Core/Model/ApiKeyConnection.cs
index fcda3abe..c103ea25 100644
--- a/runtime/csharp/Prompty.Core/Model/ApiKeyConnection.cs
+++ b/runtime/csharp/Prompty.Core/Model/ApiKeyConnection.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// Connection configuration for AI services using API keys.
 /// </summary>
-public class ApiKeyConnection : Connection
+public partial class ApiKeyConnection : Connection
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -41,6 +41,7 @@ public ApiKeyConnection()
     public string ApiKey { get; set; } = string.Empty;
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -84,7 +85,6 @@ public ApiKeyConnection()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -107,20 +107,13 @@ public ApiKeyConnection()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Endpoint is not null)
-        {
-            result["endpoint"] = obj.Endpoint;
-        }
 
-        if (obj.ApiKey is not null)
-        {
-            result["apiKey"] = obj.ApiKey;
-        }
+        result["endpoint"] = obj.Endpoint;
+
+
+        result["apiKey"] = obj.ApiKey;
 
 
         return result;
diff --git a/runtime/csharp/Prompty.Core/Model/ArrayProperty.cs b/runtime/csharp/Prompty.Core/Model/ArrayProperty.cs
index 93aa7b7e..24d31f62 100644
--- a/runtime/csharp/Prompty.Core/Model/ArrayProperty.cs
+++ b/runtime/csharp/Prompty.Core/Model/ArrayProperty.cs
@@ -8,9 +8,10 @@ namespace Prompty.Core;
 
 /// <summary>
 /// Represents an array property.
+/// 
 /// This extends the base Property model to represent an array of items.
 /// </summary>
-public class ArrayProperty : Property
+public partial class ArrayProperty : Property
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -27,7 +28,7 @@ public ArrayProperty()
 #pragma warning restore CS8618
 
     /// <summary>
-    /// 
+    /// Kind
     /// </summary>
     public override string Kind { get; set; } = "array";
 
@@ -37,6 +38,7 @@ public ArrayProperty()
     public Property Items { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -75,7 +77,6 @@ public ArrayProperty()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -98,15 +99,10 @@ public ArrayProperty()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Items is not null)
-        {
-            result["items"] = obj.Items?.Save(context);
-        }
+
+        result["items"] = obj.Items?.Save(context);
 
 
         return result;
diff --git a/runtime/csharp/Prompty.Core/Model/AudioPart.cs b/runtime/csharp/Prompty.Core/Model/AudioPart.cs
new file mode 100644
index 00000000..8e31fdf6
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/AudioPart.cs
@@ -0,0 +1,180 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// An audio content part. The source may be a URL or base64-encoded data.
+/// </summary>
+public partial class AudioPart : ContentPart
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public new static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="AudioPart"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public AudioPart()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind identifier for audio content
+    /// </summary>
+    public override string Kind { get; set; } = "audio";
+
+    /// <summary>
+    /// URL or base64-encoded audio data
+    /// </summary>
+    public string Source { get; set; } = string.Empty;
+
+    /// <summary>
+    /// MIME type of the audio (e.g., 'audio/wav')
+    /// </summary>
+    public string? MediaType { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a AudioPart instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded AudioPart instance.</returns>
+    public new static AudioPart Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new AudioPart();
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("source", out var sourceValue) && sourceValue is not null)
+        {
+            instance.Source = sourceValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("mediaType", out var mediaTypeValue) && mediaTypeValue is not null)
+        {
+            instance.MediaType = mediaTypeValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the AudioPart instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public override Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        // Start with parent class properties
+        var result = base.Save(context);
+
+
+        result["kind"] = obj.Kind;
+
+
+        result["source"] = obj.Source;
+
+
+        if (obj.MediaType is not null)
+        {
+            result["mediaType"] = obj.MediaType;
+        }
+
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the AudioPart instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public new string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the AudioPart instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public new string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a AudioPart instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded AudioPart instance.</returns>
+    public new static AudioPart FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a AudioPart instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded AudioPart instance.</returns>
+    public new static AudioPart FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/Binding.cs b/runtime/csharp/Prompty.Core/Model/Binding.cs
index ce9d737f..1990e8f3 100644
--- a/runtime/csharp/Prompty.Core/Model/Binding.cs
+++ b/runtime/csharp/Prompty.Core/Model/Binding.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// Represents a binding between an input property and a tool parameter.
 /// </summary>
-public class Binding
+public partial class Binding
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -36,6 +36,7 @@ public Binding()
     public string Input { get; set; } = string.Empty;
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -53,7 +54,6 @@ public static Binding Load(Dictionary<string, object?> data, LoadContext? contex
 
         // Note: Alternate (shorthand) representations are handled by the converter
 
-
         // Create new instance
         var instance = new Binding();
 
@@ -76,7 +76,6 @@ public static Binding Load(Dictionary<string, object?> data, LoadContext? contex
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -98,15 +97,10 @@ public static Binding Load(Dictionary<string, object?> data, LoadContext? contex
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Name is not null)
-        {
-            result["name"] = obj.Name;
-        }
+        result["name"] = obj.Name;
 
-        if (obj.Input is not null)
-        {
-            result["input"] = obj.Input;
-        }
+
+        result["input"] = obj.Input;
 
 
         if (context is not null)
diff --git a/runtime/csharp/Prompty.Core/Model/CompactionCompletePayload.cs b/runtime/csharp/Prompty.Core/Model/CompactionCompletePayload.cs
new file mode 100644
index 00000000..ab81e80c
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/CompactionCompletePayload.cs
@@ -0,0 +1,168 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "compaction_complete" events — context compaction finished.
+/// </summary>
+public partial class CompactionCompletePayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="CompactionCompletePayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public CompactionCompletePayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// Number of messages removed during compaction
+    /// </summary>
+    public int Removed { get; set; }
+
+    /// <summary>
+    /// Number of messages remaining after compaction
+    /// </summary>
+    public int Remaining { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a CompactionCompletePayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded CompactionCompletePayload instance.</returns>
+    public static CompactionCompletePayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new CompactionCompletePayload();
+
+
+        if (data.TryGetValue("removed", out var removedValue) && removedValue is not null)
+        {
+            instance.Removed = Convert.ToInt32(removedValue);
+        }
+
+        if (data.TryGetValue("remaining", out var remainingValue) && remainingValue is not null)
+        {
+            instance.Remaining = Convert.ToInt32(remainingValue);
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the CompactionCompletePayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["removed"] = obj.Removed;
+
+
+        result["remaining"] = obj.Remaining;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the CompactionCompletePayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the CompactionCompletePayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a CompactionCompletePayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded CompactionCompletePayload instance.</returns>
+    public static CompactionCompletePayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a CompactionCompletePayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded CompactionCompletePayload instance.</returns>
+    public static CompactionCompletePayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/CompactionConfig.cs b/runtime/csharp/Prompty.Core/Model/CompactionConfig.cs
new file mode 100644
index 00000000..cd757c3e
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/CompactionConfig.cs
@@ -0,0 +1,194 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Configuration for context window compaction. When the message history
+/// 
+/// exceeds the context budget, the compaction strategy is applied to
+/// 
+/// reduce the message list while preserving essential information.
+/// </summary>
+public partial class CompactionConfig
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="CompactionConfig"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public CompactionConfig()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The compaction strategy identifier. Built-in strategies include 'summarize'. Can also be a path to a .prompty file used as the summarization prompt.
+    /// </summary>
+    public string? Strategy { get; set; }
+
+    /// <summary>
+    /// Character budget for the compacted context. Overrides TurnOptions.contextBudget when set.
+    /// </summary>
+    public int? Budget { get; set; }
+
+    /// <summary>
+    /// Additional strategy-specific options
+    /// </summary>
+    public IDictionary<string, object>? Options { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a CompactionConfig instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded CompactionConfig instance.</returns>
+    public static CompactionConfig Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new CompactionConfig();
+
+
+        if (data.TryGetValue("strategy", out var strategyValue) && strategyValue is not null)
+        {
+            instance.Strategy = strategyValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("budget", out var budgetValue) && budgetValue is not null)
+        {
+            instance.Budget = Convert.ToInt32(budgetValue);
+        }
+
+        if (data.TryGetValue("options", out var optionsValue) && optionsValue is not null)
+        {
+            instance.Options = optionsValue.GetDictionary()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the CompactionConfig instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        if (obj.Strategy is not null)
+        {
+            result["strategy"] = obj.Strategy;
+        }
+
+
+        if (obj.Budget is not null)
+        {
+            result["budget"] = obj.Budget;
+        }
+
+
+        if (obj.Options is not null)
+        {
+            result["options"] = obj.Options;
+        }
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the CompactionConfig instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the CompactionConfig instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a CompactionConfig instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded CompactionConfig instance.</returns>
+    public static CompactionConfig FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a CompactionConfig instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded CompactionConfig instance.</returns>
+    public static CompactionConfig FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/CompactionFailedPayload.cs b/runtime/csharp/Prompty.Core/Model/CompactionFailedPayload.cs
new file mode 100644
index 00000000..b6f8693c
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/CompactionFailedPayload.cs
@@ -0,0 +1,155 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "compaction_failed" events — compaction could not be completed.
+/// </summary>
+public partial class CompactionFailedPayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="CompactionFailedPayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public CompactionFailedPayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// Explanation of why compaction failed
+    /// </summary>
+    public string Message { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a CompactionFailedPayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded CompactionFailedPayload instance.</returns>
+    public static CompactionFailedPayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new CompactionFailedPayload();
+
+
+        if (data.TryGetValue("message", out var messageValue) && messageValue is not null)
+        {
+            instance.Message = messageValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the CompactionFailedPayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["message"] = obj.Message;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the CompactionFailedPayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the CompactionFailedPayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a CompactionFailedPayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded CompactionFailedPayload instance.</returns>
+    public static CompactionFailedPayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a CompactionFailedPayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded CompactionFailedPayload instance.</returns>
+    public static CompactionFailedPayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/Connection.cs b/runtime/csharp/Prompty.Core/Model/Connection.cs
index d82a7512..4deaed81 100644
--- a/runtime/csharp/Prompty.Core/Model/Connection.cs
+++ b/runtime/csharp/Prompty.Core/Model/Connection.cs
@@ -8,10 +8,12 @@ namespace Prompty.Core;
 
 /// <summary>
 /// Connection configuration for AI agents.
+/// 
 /// `provider`, `kind`, and `endpoint` are required properties here,
+/// 
 /// but this section can accept additional via options.
 /// </summary>
-public abstract class Connection
+public abstract partial class Connection
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -43,6 +45,7 @@ protected Connection()
     public string? UsageDescription { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -86,7 +89,6 @@ public static Connection Load(Dictionary<string, object?> data, LoadContext? con
     }
 
 
-
     /// <summary>
     /// Load polymorphic Connection based on discriminator.
     /// </summary>
@@ -133,16 +135,15 @@ private static Connection LoadKind(Dictionary<string, object?> data, LoadContext
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
+
 
         if (obj.AuthenticationMode is not null)
         {
             result["authenticationMode"] = obj.AuthenticationMode;
         }
 
+
         if (obj.UsageDescription is not null)
         {
             result["usageDescription"] = obj.UsageDescription;
diff --git a/runtime/csharp/Prompty.Core/Model/ContentPart.cs b/runtime/csharp/Prompty.Core/Model/ContentPart.cs
new file mode 100644
index 00000000..8bf55070
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ContentPart.cs
@@ -0,0 +1,180 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// A part of a message's content. Content parts are discriminated on the `kind`
+/// 
+/// field and represent the different modalities that can appear in a message.
+/// </summary>
+public abstract partial class ContentPart
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ContentPart"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    protected ContentPart()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind of content part
+    /// </summary>
+    public virtual string Kind { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ContentPart instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ContentPart instance.</returns>
+    public static ContentPart Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Load polymorphic ContentPart instance
+        var instance = LoadKind(data, context);
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    /// <summary>
+    /// Load polymorphic ContentPart based on discriminator.
+    /// </summary>
+    private static ContentPart LoadKind(Dictionary<string, object?> data, LoadContext? context)
+    {
+        if (data.TryGetValue("kind", out var discriminatorValue) && discriminatorValue is not null)
+        {
+            var discriminator = discriminatorValue.ToString()?.ToLowerInvariant();
+            return discriminator switch
+            {
+                "text" => TextPart.Load(data, context),
+                "image" => ImagePart.Load(data, context),
+                "file" => FilePart.Load(data, context),
+                "audio" => AudioPart.Load(data, context),
+                _ => throw new ArgumentException($"Unknown ContentPart discriminator value: {discriminator}"),
+            };
+        }
+
+        throw new ArgumentException("Missing ContentPart discriminator property: 'kind'");
+
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ContentPart instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public virtual Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["kind"] = obj.Kind;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ContentPart instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ContentPart instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ContentPart instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ContentPart instance.</returns>
+    public static ContentPart FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ContentPart instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ContentPart instance.</returns>
+    public static ContentPart FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/CustomTool.cs b/runtime/csharp/Prompty.Core/Model/CustomTool.cs
index dc6f88ba..f6cef50c 100644
--- a/runtime/csharp/Prompty.Core/Model/CustomTool.cs
+++ b/runtime/csharp/Prompty.Core/Model/CustomTool.cs
@@ -8,12 +8,16 @@ namespace Prompty.Core;
 
 /// <summary>
 /// Represents a generic server tool that runs on a server
+/// 
 /// This tool kind is designed for operations that require server-side execution
+/// 
 /// It may include features such as authentication, data storage, and long-running processes
+/// 
 /// This tool kind is ideal for tasks that involve complex computations or access to secure resources
+/// 
 /// Server tools can be used to offload heavy processing from client applications
 /// </summary>
-public class CustomTool : Tool
+public partial class CustomTool : Tool
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -45,6 +49,7 @@ public CustomTool()
     public IDictionary<string, object> Options { get; set; } = new Dictionary<string, object>();
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -88,7 +93,6 @@ public CustomTool()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -111,20 +115,13 @@ public CustomTool()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Connection is not null)
-        {
-            result["connection"] = obj.Connection?.Save(context);
-        }
 
-        if (obj.Options is not null)
-        {
-            result["options"] = obj.Options;
-        }
+        result["connection"] = obj.Connection?.Save(context);
+
+
+        result["options"] = obj.Options;
 
 
         return result;
diff --git a/runtime/csharp/Prompty.Core/Model/DoneEventPayload.cs b/runtime/csharp/Prompty.Core/Model/DoneEventPayload.cs
new file mode 100644
index 00000000..3845e84b
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/DoneEventPayload.cs
@@ -0,0 +1,235 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "done" events — the agent loop completed successfully.
+/// </summary>
+public partial class DoneEventPayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="DoneEventPayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public DoneEventPayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The final text response from the LLM
+    /// </summary>
+    public string Response { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The final conversation state including all messages
+    /// </summary>
+    public IList<Message> Messages { get; set; } = [];
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a DoneEventPayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded DoneEventPayload instance.</returns>
+    public static DoneEventPayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new DoneEventPayload();
+
+
+        if (data.TryGetValue("response", out var responseValue) && responseValue is not null)
+        {
+            instance.Response = responseValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("messages", out var messagesValue) && messagesValue is not null)
+        {
+            instance.Messages = LoadMessages(messagesValue, context);
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    /// <summary>
+    /// Load a list of Message from a dictionary or list.
+    /// </summary>
+    public static IList<Message> LoadMessages(object data, LoadContext? context)
+    {
+        var result = new List<Message>();
+
+        if (data is Dictionary<string, object?> dict)
+        {
+            // Convert named dictionary to list
+            foreach (var kvp in dict)
+            {
+                if (kvp.Value is IEnumerable<object>)
+                {
+                    throw new ArgumentException(
+                        $"Invalid 'messages' format: key '{kvp.Key}' has an array value. " +
+                        $"'messages' must be a flat list of objects or a name-keyed dict — " +
+                        "not a nested {" + kvp.Key + ": [...]} structure.");
+                }
+                var itemDict = kvp.Value.GetDictionary();
+                if (itemDict.Count > 0)
+                {
+                    // Value is an object, add name to it
+                    itemDict["name"] = kvp.Key;
+                    result.Add(Message.Load(itemDict, context));
+                }
+                else
+                {
+                    // Value is a scalar, use it as the primary property
+                    var newDict = new Dictionary<string, object?>
+                    {
+                        ["name"] = kvp.Key,
+                        ["role"] = kvp.Value
+                    };
+                    result.Add(Message.Load(newDict, context));
+                }
+            }
+        }
+        else if (data is IEnumerable<object> list)
+        {
+            foreach (var item in list)
+            {
+                var itemDict = item.GetDictionary(Message.ShorthandProperty);
+                if (itemDict.Count > 0)
+                {
+                    result.Add(Message.Load(itemDict, context));
+                }
+            }
+        }
+
+        return result;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the DoneEventPayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["response"] = obj.Response;
+
+
+        result["messages"] = SaveMessages(obj.Messages, context);
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Save a list of Message to object or array format.
+    /// </summary>
+    public static object SaveMessages(IList<Message> items, SaveContext? context)
+    {
+        context ??= new SaveContext();
+
+        // This collection type does not have a 'name' property, only array format is supported
+        return items.Select(item => item.Save(context)).ToList();
+
+    }
+
+
+    /// <summary>
+    /// Convert the DoneEventPayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the DoneEventPayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a DoneEventPayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded DoneEventPayload instance.</returns>
+    public static DoneEventPayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a DoneEventPayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded DoneEventPayload instance.</returns>
+    public static DoneEventPayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ErrorChunk.cs b/runtime/csharp/Prompty.Core/Model/ErrorChunk.cs
new file mode 100644
index 00000000..430616bf
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ErrorChunk.cs
@@ -0,0 +1,164 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// An error chunk from the LLM response stream.
+/// </summary>
+public partial class ErrorChunk : StreamChunk
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public new static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ErrorChunk"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ErrorChunk()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind identifier for error chunks
+    /// </summary>
+    public override string Kind { get; set; } = "error";
+
+    /// <summary>
+    /// The error message
+    /// </summary>
+    public string Message { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ErrorChunk instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ErrorChunk instance.</returns>
+    public new static ErrorChunk Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ErrorChunk();
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("message", out var messageValue) && messageValue is not null)
+        {
+            instance.Message = messageValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ErrorChunk instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public override Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        // Start with parent class properties
+        var result = base.Save(context);
+
+
+        result["kind"] = obj.Kind;
+
+
+        result["message"] = obj.Message;
+
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ErrorChunk instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public new string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ErrorChunk instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public new string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ErrorChunk instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ErrorChunk instance.</returns>
+    public new static ErrorChunk FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ErrorChunk instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ErrorChunk instance.</returns>
+    public new static ErrorChunk FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ErrorEventPayload.cs b/runtime/csharp/Prompty.Core/Model/ErrorEventPayload.cs
new file mode 100644
index 00000000..8513e878
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ErrorEventPayload.cs
@@ -0,0 +1,155 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "error" events — an error occurred during the loop.
+/// </summary>
+public partial class ErrorEventPayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ErrorEventPayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ErrorEventPayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// Human-readable error description
+    /// </summary>
+    public string Message { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ErrorEventPayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ErrorEventPayload instance.</returns>
+    public static ErrorEventPayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ErrorEventPayload();
+
+
+        if (data.TryGetValue("message", out var messageValue) && messageValue is not null)
+        {
+            instance.Message = messageValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ErrorEventPayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["message"] = obj.Message;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ErrorEventPayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ErrorEventPayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ErrorEventPayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ErrorEventPayload instance.</returns>
+    public static ErrorEventPayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ErrorEventPayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ErrorEventPayload instance.</returns>
+    public static ErrorEventPayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/Executor.cs b/runtime/csharp/Prompty.Core/Model/Executor.cs
new file mode 100644
index 00000000..3ed3cd9b
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/Executor.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Calls an LLM provider with messages and returns the raw provider response.
+/// </summary>
+public interface IExecutor
+{
+    /// <summary>
+    /// Call an LLM provider with messages and return the raw response
+    /// </summary>
+    Task<object> ExecuteAsync(Prompty agent, List<Message> messages);
+    /// <summary>
+    /// Call an LLM provider and return a streaming response. Returns a language-specific async iterable/stream of raw chunks. Not all providers support streaming; the default implementation should signal lack of support.
+    /// </summary>
+    Task<object> ExecuteStreamAsync(Prompty agent, List<Message> messages) => Task.FromResult<object>(default);
+    /// <summary>
+    /// Format tool call results into messages for the next iteration
+    /// </summary>
+    List<Message> FormatToolMessages(object rawResponse, List<ToolCall> toolCalls, List<string> toolResults, string? textContent);
+}
diff --git a/runtime/csharp/Prompty.Core/Model/FilePart.cs b/runtime/csharp/Prompty.Core/Model/FilePart.cs
new file mode 100644
index 00000000..14082700
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/FilePart.cs
@@ -0,0 +1,180 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// A file content part. The source may be a URL or base64-encoded data.
+/// </summary>
+public partial class FilePart : ContentPart
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public new static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="FilePart"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public FilePart()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind identifier for file content
+    /// </summary>
+    public override string Kind { get; set; } = "file";
+
+    /// <summary>
+    /// URL or base64-encoded file data
+    /// </summary>
+    public string Source { get; set; } = string.Empty;
+
+    /// <summary>
+    /// MIME type of the file (e.g., 'application/pdf')
+    /// </summary>
+    public string? MediaType { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a FilePart instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded FilePart instance.</returns>
+    public new static FilePart Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new FilePart();
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("source", out var sourceValue) && sourceValue is not null)
+        {
+            instance.Source = sourceValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("mediaType", out var mediaTypeValue) && mediaTypeValue is not null)
+        {
+            instance.MediaType = mediaTypeValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the FilePart instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public override Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        // Start with parent class properties
+        var result = base.Save(context);
+
+
+        result["kind"] = obj.Kind;
+
+
+        result["source"] = obj.Source;
+
+
+        if (obj.MediaType is not null)
+        {
+            result["mediaType"] = obj.MediaType;
+        }
+
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the FilePart instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public new string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the FilePart instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public new string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a FilePart instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded FilePart instance.</returns>
+    public new static FilePart FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a FilePart instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded FilePart instance.</returns>
+    public new static FilePart FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/FormatConfig.cs b/runtime/csharp/Prompty.Core/Model/FormatConfig.cs
index 4fe7ed5d..7eeab289 100644
--- a/runtime/csharp/Prompty.Core/Model/FormatConfig.cs
+++ b/runtime/csharp/Prompty.Core/Model/FormatConfig.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// Template format definition
 /// </summary>
-public class FormatConfig
+public partial class FormatConfig
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -41,6 +41,7 @@ public FormatConfig()
     public IDictionary<string, object>? Options { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -58,7 +59,6 @@ public static FormatConfig Load(Dictionary<string, object?> data, LoadContext? c
 
         // Note: Alternate (shorthand) representations are handled by the converter
 
-
         // Create new instance
         var instance = new FormatConfig();
 
@@ -86,7 +86,6 @@ public static FormatConfig Load(Dictionary<string, object?> data, LoadContext? c
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -108,16 +107,15 @@ public static FormatConfig Load(Dictionary<string, object?> data, LoadContext? c
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
+
 
         if (obj.Strict is not null)
         {
             result["strict"] = obj.Strict;
         }
 
+
         if (obj.Options is not null)
         {
             result["options"] = obj.Options;
diff --git a/runtime/csharp/Prompty.Core/Model/FoundryConnection.cs b/runtime/csharp/Prompty.Core/Model/FoundryConnection.cs
index 2402c861..5be78291 100644
--- a/runtime/csharp/Prompty.Core/Model/FoundryConnection.cs
+++ b/runtime/csharp/Prompty.Core/Model/FoundryConnection.cs
@@ -8,10 +8,12 @@ namespace Prompty.Core;
 
 /// <summary>
 /// Connection configuration for Microsoft Foundry projects.
+/// 
 /// Provides project-scoped access to models, tools, and services
+/// 
 /// via Entra ID (DefaultAzureCredential) authentication.
 /// </summary>
-public class FoundryConnection : Connection
+public partial class FoundryConnection : Connection
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -48,6 +50,7 @@ public FoundryConnection()
     public string? ConnectionType { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -96,7 +99,6 @@ public FoundryConnection()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -119,21 +121,18 @@ public FoundryConnection()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
+
+
+        result["endpoint"] = obj.Endpoint;
 
-        if (obj.Endpoint is not null)
-        {
-            result["endpoint"] = obj.Endpoint;
-        }
 
         if (obj.Name is not null)
         {
             result["name"] = obj.Name;
         }
 
+
         if (obj.ConnectionType is not null)
         {
             result["connectionType"] = obj.ConnectionType;
diff --git a/runtime/csharp/Prompty.Core/Model/FunctionTool.cs b/runtime/csharp/Prompty.Core/Model/FunctionTool.cs
index 6ff23ec5..6a8bb165 100644
--- a/runtime/csharp/Prompty.Core/Model/FunctionTool.cs
+++ b/runtime/csharp/Prompty.Core/Model/FunctionTool.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// Represents a local function tool.
 /// </summary>
-public class FunctionTool : Tool
+public partial class FunctionTool : Tool
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -41,6 +41,7 @@ public FunctionTool()
     public bool? Strict { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -138,7 +139,6 @@ public static IList<Property> LoadParameters(object data, LoadContext? context)
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -161,15 +161,11 @@ public static IList<Property> LoadParameters(object data, LoadContext? context)
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
+
+
+        result["parameters"] = SaveParameters(obj.Parameters, context);
 
-        if (obj.Parameters is not null)
-        {
-            result["parameters"] = SaveParameters(obj.Parameters, context);
-        }
 
         if (obj.Strict is not null)
         {
@@ -188,39 +184,8 @@ public static object SaveParameters(IList<Property> items, SaveContext? context)
     {
         context ??= new SaveContext();
 
-
-        if (context.CollectionFormat == "array")
-        {
-            return items.Select(item => item.Save(context)).ToList();
-        }
-
-        // Object format: use name as key
-        var result = new Dictionary<string, object?>();
-        foreach (var item in items)
-        {
-            var itemData = item.Save(context);
-            if (itemData.TryGetValue("name", out var nameValue) && nameValue is string name)
-            {
-                itemData.Remove("name");
-
-                // Check if we can use shorthand
-                if (context.UseShorthand && Property.ShorthandProperty is string shorthandProp)
-                {
-                    if (itemData.Count == 1 && itemData.ContainsKey(shorthandProp))
-                    {
-                        result[name] = itemData[shorthandProp];
-                        continue;
-                    }
-                }
-                result[name] = itemData;
-            }
-            else
-            {
-                // No name, can't use object format for this item
-                throw new InvalidOperationException("Cannot save item in object format: missing 'name' property");
-            }
-        }
-        return result;
+        // This collection type does not have a 'name' property, only array format is supported
+        return items.Select(item => item.Save(context)).ToList();
 
     }
 
diff --git a/runtime/csharp/Prompty.Core/Model/GuardrailResult.cs b/runtime/csharp/Prompty.Core/Model/GuardrailResult.cs
new file mode 100644
index 00000000..bd8b00c9
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/GuardrailResult.cs
@@ -0,0 +1,219 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// The result of a guardrail evaluation. Guardrails are safety checks that
+/// 
+/// run at specific phases of the agent loop and can allow, deny, or rewrite
+/// 
+/// content.
+/// </summary>
+public partial class GuardrailResult
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="GuardrailResult"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public GuardrailResult()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// Whether the content passed the guardrail check
+    /// </summary>
+    public bool Allowed { get; set; } = false;
+
+    /// <summary>
+    /// Explanation of why the content was allowed or denied
+    /// </summary>
+    public string? Reason { get; set; }
+
+    /// <summary>
+    /// Optional rewritten content to replace the original
+    /// </summary>
+    public object? Rewrite { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a GuardrailResult instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded GuardrailResult instance.</returns>
+    public static GuardrailResult Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new GuardrailResult();
+
+
+        if (data.TryGetValue("allowed", out var allowedValue) && allowedValue is not null)
+        {
+            instance.Allowed = Convert.ToBoolean(allowedValue);
+        }
+
+        if (data.TryGetValue("reason", out var reasonValue) && reasonValue is not null)
+        {
+            instance.Reason = reasonValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("rewrite", out var rewriteValue) && rewriteValue is not null)
+        {
+            instance.Rewrite = rewriteValue;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the GuardrailResult instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["allowed"] = obj.Allowed;
+
+
+        if (obj.Reason is not null)
+        {
+            result["reason"] = obj.Reason;
+        }
+
+
+        if (obj.Rewrite is not null)
+        {
+            result["rewrite"] = obj.Rewrite;
+        }
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the GuardrailResult instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the GuardrailResult instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a GuardrailResult instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded GuardrailResult instance.</returns>
+    public static GuardrailResult FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a GuardrailResult instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded GuardrailResult instance.</returns>
+    public static GuardrailResult FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+
+    #region Factory Methods
+
+    /// <summary>
+    /// Create a GuardrailResult with preset field values.
+    /// </summary>
+    public static GuardrailResult CreateRewrite(object? rewrite)
+    {
+        return new GuardrailResult { Allowed = true, Rewrite = rewrite };
+    }
+
+    /// <summary>
+    /// Create a GuardrailResult with preset field values.
+    /// </summary>
+    public static GuardrailResult Deny(string reason)
+    {
+        return new GuardrailResult { Allowed = false, Reason = reason };
+    }
+
+    /// <summary>
+    /// Create a GuardrailResult with preset field values.
+    /// </summary>
+    public static GuardrailResult Allow()
+    {
+        return new GuardrailResult { Allowed = true };
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/GuardrailResultExtensions.cs b/runtime/csharp/Prompty.Core/Model/GuardrailResultExtensions.cs
new file mode 100644
index 00000000..9b8cb904
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/GuardrailResultExtensions.cs
@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+public partial class GuardrailResult
+{
+    /// <summary>
+    /// Convenience constructor matching the old record signature.
+    /// </summary>
+    public GuardrailResult(bool allowed, string? reason = null, object? rewrite = null)
+    {
+        Allowed = allowed;
+        Reason = reason;
+        Rewrite = rewrite;
+    }
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ImagePart.cs b/runtime/csharp/Prompty.Core/Model/ImagePart.cs
new file mode 100644
index 00000000..db67e64e
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ImagePart.cs
@@ -0,0 +1,196 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// An image content part. The source may be a URL or base64-encoded data.
+/// </summary>
+public partial class ImagePart : ContentPart
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public new static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ImagePart"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ImagePart()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind identifier for image content
+    /// </summary>
+    public override string Kind { get; set; } = "image";
+
+    /// <summary>
+    /// URL or base64-encoded image data
+    /// </summary>
+    public string Source { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Detail level hint for the model (e.g., 'auto', 'low', 'high')
+    /// </summary>
+    public string? Detail { get; set; }
+
+    /// <summary>
+    /// MIME type of the image (e.g., 'image/png')
+    /// </summary>
+    public string? MediaType { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ImagePart instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ImagePart instance.</returns>
+    public new static ImagePart Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ImagePart();
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("source", out var sourceValue) && sourceValue is not null)
+        {
+            instance.Source = sourceValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("detail", out var detailValue) && detailValue is not null)
+        {
+            instance.Detail = detailValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("mediaType", out var mediaTypeValue) && mediaTypeValue is not null)
+        {
+            instance.MediaType = mediaTypeValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ImagePart instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public override Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        // Start with parent class properties
+        var result = base.Save(context);
+
+
+        result["kind"] = obj.Kind;
+
+
+        result["source"] = obj.Source;
+
+
+        if (obj.Detail is not null)
+        {
+            result["detail"] = obj.Detail;
+        }
+
+
+        if (obj.MediaType is not null)
+        {
+            result["mediaType"] = obj.MediaType;
+        }
+
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ImagePart instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public new string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ImagePart instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public new string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ImagePart instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ImagePart instance.</returns>
+    public new static ImagePart FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ImagePart instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ImagePart instance.</returns>
+    public new static ImagePart FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/McpApprovalMode.cs b/runtime/csharp/Prompty.Core/Model/McpApprovalMode.cs
index f7e7716b..d281c400 100644
--- a/runtime/csharp/Prompty.Core/Model/McpApprovalMode.cs
+++ b/runtime/csharp/Prompty.Core/Model/McpApprovalMode.cs
@@ -8,10 +8,12 @@ namespace Prompty.Core;
 
 /// <summary>
 /// The approval mode for MCP server tools.
-/// When kind is &quot;specify&quot;, use alwaysRequireApprovalTools and neverRequireApprovalTools
-/// to control per-tool approval. For &quot;always&quot; and &quot;never&quot;, those fields are ignored.
+/// 
+/// When kind is "specify", use alwaysRequireApprovalTools and neverRequireApprovalTools
+/// 
+/// to control per-tool approval. For "always" and "never", those fields are ignored.
 /// </summary>
-public class McpApprovalMode
+public partial class McpApprovalMode
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -43,6 +45,7 @@ public McpApprovalMode()
     public IList<string>? NeverRequireApprovalTools { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -60,7 +63,6 @@ public static McpApprovalMode Load(Dictionary<string, object?> data, LoadContext
 
         // Note: Alternate (shorthand) representations are handled by the converter
 
-
         // Create new instance
         var instance = new McpApprovalMode();
 
@@ -88,7 +90,6 @@ public static McpApprovalMode Load(Dictionary<string, object?> data, LoadContext
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -110,16 +111,15 @@ public static McpApprovalMode Load(Dictionary<string, object?> data, LoadContext
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
+
 
         if (obj.AlwaysRequireApprovalTools is not null)
         {
             result["alwaysRequireApprovalTools"] = obj.AlwaysRequireApprovalTools;
         }
 
+
         if (obj.NeverRequireApprovalTools is not null)
         {
             result["neverRequireApprovalTools"] = obj.NeverRequireApprovalTools;
diff --git a/runtime/csharp/Prompty.Core/Model/McpTool.cs b/runtime/csharp/Prompty.Core/Model/McpTool.cs
index 656a1c4a..8ce8e077 100644
--- a/runtime/csharp/Prompty.Core/Model/McpTool.cs
+++ b/runtime/csharp/Prompty.Core/Model/McpTool.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// The MCP Server tool.
 /// </summary>
-public class McpTool : Tool
+public partial class McpTool : Tool
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -56,6 +56,7 @@ public McpTool()
     public IList<string>? AllowedTools { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -114,7 +115,6 @@ public McpTool()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -137,30 +137,23 @@ public McpTool()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Connection is not null)
-        {
-            result["connection"] = obj.Connection?.Save(context);
-        }
 
-        if (obj.ServerName is not null)
-        {
-            result["serverName"] = obj.ServerName;
-        }
+        result["connection"] = obj.Connection?.Save(context);
+
+
+        result["serverName"] = obj.ServerName;
+
 
         if (obj.ServerDescription is not null)
         {
             result["serverDescription"] = obj.ServerDescription;
         }
 
-        if (obj.ApprovalMode is not null)
-        {
-            result["approvalMode"] = obj.ApprovalMode?.Save(context);
-        }
+
+        result["approvalMode"] = obj.ApprovalMode?.Save(context);
+
 
         if (obj.AllowedTools is not null)
         {
diff --git a/runtime/csharp/Prompty.Core/Model/Message.cs b/runtime/csharp/Prompty.Core/Model/Message.cs
new file mode 100644
index 00000000..288e70b3
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/Message.cs
@@ -0,0 +1,297 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// A message in a conversation. Messages have a role and a list of content parts
+/// 
+/// representing the different modalities of the message content.
+/// </summary>
+public partial class Message : IMessageHelpers
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="Message"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public Message()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The role of the message sender
+    /// </summary>
+    public string Role { get; set; } = "user";
+
+    /// <summary>
+    /// The content parts of the message
+    /// </summary>
+    public IList<ContentPart> Parts { get; set; } = [];
+
+    /// <summary>
+    /// Optional metadata associated with the message
+    /// </summary>
+    public IDictionary<string, object> Metadata { get; set; } = new Dictionary<string, object>();
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a Message instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded Message instance.</returns>
+    public static Message Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new Message();
+
+
+        if (data.TryGetValue("role", out var roleValue) && roleValue is not null)
+        {
+            instance.Role = roleValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("parts", out var partsValue) && partsValue is not null)
+        {
+            instance.Parts = LoadParts(partsValue, context);
+        }
+
+        if (data.TryGetValue("metadata", out var metadataValue) && metadataValue is not null)
+        {
+            instance.Metadata = metadataValue.GetDictionary()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    /// <summary>
+    /// Load a list of ContentPart from a dictionary or list.
+    /// </summary>
+    public static IList<ContentPart> LoadParts(object data, LoadContext? context)
+    {
+        var result = new List<ContentPart>();
+
+        if (data is Dictionary<string, object?> dict)
+        {
+            // Convert named dictionary to list
+            foreach (var kvp in dict)
+            {
+                if (kvp.Value is IEnumerable<object>)
+                {
+                    throw new ArgumentException(
+                        $"Invalid 'parts' format: key '{kvp.Key}' has an array value. " +
+                        $"'parts' must be a flat list of objects or a name-keyed dict — " +
+                        "not a nested {" + kvp.Key + ": [...]} structure.");
+                }
+                var itemDict = kvp.Value.GetDictionary();
+                if (itemDict.Count > 0)
+                {
+                    // Value is an object, add name to it
+                    itemDict["name"] = kvp.Key;
+                    result.Add(ContentPart.Load(itemDict, context));
+                }
+                else
+                {
+                    // Value is a scalar, use it as the primary property
+                    var newDict = new Dictionary<string, object?>
+                    {
+                        ["name"] = kvp.Key,
+                        ["kind"] = kvp.Value
+                    };
+                    result.Add(ContentPart.Load(newDict, context));
+                }
+            }
+        }
+        else if (data is IEnumerable<object> list)
+        {
+            foreach (var item in list)
+            {
+                var itemDict = item.GetDictionary(ContentPart.ShorthandProperty);
+                if (itemDict.Count > 0)
+                {
+                    result.Add(ContentPart.Load(itemDict, context));
+                }
+            }
+        }
+
+        return result;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the Message instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["role"] = obj.Role;
+
+
+        result["parts"] = SaveParts(obj.Parts, context);
+
+
+        result["metadata"] = obj.Metadata;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Save a list of ContentPart to object or array format.
+    /// </summary>
+    public static object SaveParts(IList<ContentPart> items, SaveContext? context)
+    {
+        context ??= new SaveContext();
+
+        // This collection type does not have a 'name' property, only array format is supported
+        return items.Select(item => item.Save(context)).ToList();
+
+    }
+
+
+    /// <summary>
+    /// Convert the Message instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the Message instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a Message instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded Message instance.</returns>
+    public static Message FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a Message instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded Message instance.</returns>
+    public static Message FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+
+    #region Factory Methods
+
+    /// <summary>
+    /// Create a Message with preset field values.
+    /// </summary>
+    public static Message Assistant(string text)
+    {
+        return new Message { Role = "assistant", Parts = new List<ContentPart> { new TextPart { Value = text } } };
+    }
+
+    /// <summary>
+    /// Create a Message with preset field values.
+    /// </summary>
+    public static Message System(string text)
+    {
+        return new Message { Role = "system", Parts = new List<ContentPart> { new TextPart { Value = text } } };
+    }
+
+    /// <summary>
+    /// Create a Message with preset field values.
+    /// </summary>
+    public static Message User(string text)
+    {
+        return new Message { Role = "user", Parts = new List<ContentPart> { new TextPart { Value = text } } };
+    }
+
+    #endregion
+}
+
+/// <summary>
+/// Helper contract for <see cref="Message"/>.
+///
+/// Runtime implementations must provide these members on Message (via a
+/// hand-written partial class). The C# compiler enforces conformance
+/// because Message declares : IMessageHelpers.
+/// </summary>
+public partial interface IMessageHelpers
+{
+    /// <summary>
+    /// Return plain string if all parts are text, else a list of content part dicts for wire serialization
+    /// </summary>
+    object ToTextContent();
+    /// <summary>
+    /// Concatenate all TextPart values joined by newline
+    /// </summary>
+    string Text { get; }
+}
diff --git a/runtime/csharp/Prompty.Core/Model/MessageHelpers.cs b/runtime/csharp/Prompty.Core/Model/MessageHelpers.cs
new file mode 100644
index 00000000..da9fd04c
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/MessageHelpers.cs
@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// --- Runtime helpers (manually maintained) ---
+// This file extends the generated Message class with convenience members
+// used by the Prompty pipeline and wire-format converters.
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+public partial class Message
+{
+    /// <summary>
+    /// Concatenated text from all TextParts.
+    /// </summary>
+    public string Text => string.Join("", Parts.OfType<TextPart>().Select(p => p.Value));
+
+    /// <summary>
+    /// Returns the content as a simple string if only text parts exist,
+    /// or as a list of wire-format dictionaries for multimodal content.
+    /// </summary>
+    public object ToTextContent()
+    {
+        if (Parts.All(p => p is TextPart))
+            return Text;
+
+        return Parts.Select<ContentPart, Dictionary<string, object?>>(p => p switch
+        {
+            TextPart t => new() { ["type"] = "text", ["text"] = t.Value },
+            ImagePart i => new()
+            {
+                ["type"] = "image_url",
+                ["image_url"] = new Dictionary<string, object?>
+                {
+                    ["url"] = i.Source,
+                    ["detail"] = i.Detail ?? "auto",
+                },
+            },
+            FilePart f => new() { ["type"] = "file", ["file"] = new Dictionary<string, object?> { ["url"] = f.Source } },
+            AudioPart a => new() { ["type"] = "input_audio", ["input_audio"] = new Dictionary<string, object?> { ["url"] = a.Source } },
+            _ => new() { ["type"] = p.Kind },
+        }).ToList();
+    }
+}
diff --git a/runtime/csharp/Prompty.Core/Model/MessagesUpdatedPayload.cs b/runtime/csharp/Prompty.Core/Model/MessagesUpdatedPayload.cs
new file mode 100644
index 00000000..cfddbe1a
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/MessagesUpdatedPayload.cs
@@ -0,0 +1,222 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "messages_updated" events — the conversation state has changed.
+/// </summary>
+public partial class MessagesUpdatedPayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="MessagesUpdatedPayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public MessagesUpdatedPayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The current full message list after the update
+    /// </summary>
+    public IList<Message> Messages { get; set; } = [];
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a MessagesUpdatedPayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded MessagesUpdatedPayload instance.</returns>
+    public static MessagesUpdatedPayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new MessagesUpdatedPayload();
+
+
+        if (data.TryGetValue("messages", out var messagesValue) && messagesValue is not null)
+        {
+            instance.Messages = LoadMessages(messagesValue, context);
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    /// <summary>
+    /// Load a list of Message from a dictionary or list.
+    /// </summary>
+    public static IList<Message> LoadMessages(object data, LoadContext? context)
+    {
+        var result = new List<Message>();
+
+        if (data is Dictionary<string, object?> dict)
+        {
+            // Convert named dictionary to list
+            foreach (var kvp in dict)
+            {
+                if (kvp.Value is IEnumerable<object>)
+                {
+                    throw new ArgumentException(
+                        $"Invalid 'messages' format: key '{kvp.Key}' has an array value. " +
+                        $"'messages' must be a flat list of objects or a name-keyed dict — " +
+                        "not a nested {" + kvp.Key + ": [...]} structure.");
+                }
+                var itemDict = kvp.Value.GetDictionary();
+                if (itemDict.Count > 0)
+                {
+                    // Value is an object, add name to it
+                    itemDict["name"] = kvp.Key;
+                    result.Add(Message.Load(itemDict, context));
+                }
+                else
+                {
+                    // Value is a scalar, use it as the primary property
+                    var newDict = new Dictionary<string, object?>
+                    {
+                        ["name"] = kvp.Key,
+                        ["role"] = kvp.Value
+                    };
+                    result.Add(Message.Load(newDict, context));
+                }
+            }
+        }
+        else if (data is IEnumerable<object> list)
+        {
+            foreach (var item in list)
+            {
+                var itemDict = item.GetDictionary(Message.ShorthandProperty);
+                if (itemDict.Count > 0)
+                {
+                    result.Add(Message.Load(itemDict, context));
+                }
+            }
+        }
+
+        return result;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the MessagesUpdatedPayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["messages"] = SaveMessages(obj.Messages, context);
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Save a list of Message to object or array format.
+    /// </summary>
+    public static object SaveMessages(IList<Message> items, SaveContext? context)
+    {
+        context ??= new SaveContext();
+
+        // This collection type does not have a 'name' property, only array format is supported
+        return items.Select(item => item.Save(context)).ToList();
+
+    }
+
+
+    /// <summary>
+    /// Convert the MessagesUpdatedPayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the MessagesUpdatedPayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a MessagesUpdatedPayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded MessagesUpdatedPayload instance.</returns>
+    public static MessagesUpdatedPayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a MessagesUpdatedPayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded MessagesUpdatedPayload instance.</returns>
+    public static MessagesUpdatedPayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/Model.cs b/runtime/csharp/Prompty.Core/Model/Model.cs
index 68fcbd53..26ed0117 100644
--- a/runtime/csharp/Prompty.Core/Model/Model.cs
+++ b/runtime/csharp/Prompty.Core/Model/Model.cs
@@ -8,10 +8,12 @@ namespace Prompty.Core;
 
 /// <summary>
 /// Model for defining the structure and behavior of AI agents.
-/// This model includes properties for specifying the model&#39;s provider, connection details, and various options.
+/// 
+/// This model includes properties for specifying the model's provider, connection details, and various options.
+/// 
 /// It allows for flexible configuration of AI models to suit different use cases and requirements.
 /// </summary>
-public class Model
+public partial class Model
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -53,6 +55,7 @@ public Model()
     public ModelOptions? Options { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -70,7 +73,6 @@ public static Model Load(Dictionary<string, object?> data, LoadContext? context
 
         // Note: Alternate (shorthand) representations are handled by the converter
 
-
         // Create new instance
         var instance = new Model();
 
@@ -108,7 +110,6 @@ public static Model Load(Dictionary<string, object?> data, LoadContext? context
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -130,26 +131,27 @@ public static Model Load(Dictionary<string, object?> data, LoadContext? context
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Id is not null)
-        {
-            result["id"] = obj.Id;
-        }
+        result["id"] = obj.Id;
+
 
         if (obj.Provider is not null)
         {
             result["provider"] = obj.Provider;
         }
 
+
         if (obj.ApiType is not null)
         {
             result["apiType"] = obj.ApiType;
         }
 
+
         if (obj.Connection is not null)
         {
             result["connection"] = obj.Connection?.Save(context);
         }
 
+
         if (obj.Options is not null)
         {
             result["options"] = obj.Options?.Save(context);
diff --git a/runtime/csharp/Prompty.Core/Model/ModelInfo.cs b/runtime/csharp/Prompty.Core/Model/ModelInfo.cs
new file mode 100644
index 00000000..14620536
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ModelInfo.cs
@@ -0,0 +1,259 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Information about a model available from a provider. Used by provider-level
+/// 
+/// model discovery to report which models are available and their capabilities.
+/// 
+/// Not all providers return all fields — implementations SHOULD populate as
+/// 
+/// many fields as the provider's API supports and MAY enrich sparse results
+/// 
+/// from a built-in lookup table of known models.
+/// </summary>
+public partial class ModelInfo
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ModelInfo"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ModelInfo()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The model identifier (e.g., 'gpt-4o', 'claude-3-opus')
+    /// </summary>
+    public string Id { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Human-readable display name
+    /// </summary>
+    public string? DisplayName { get; set; }
+
+    /// <summary>
+    /// The organization or entity that owns the model
+    /// </summary>
+    public string? OwnedBy { get; set; }
+
+    /// <summary>
+    /// Maximum context window size in tokens
+    /// </summary>
+    public int? ContextWindow { get; set; }
+
+    /// <summary>
+    /// Input modalities the model accepts (e.g., 'text', 'image', 'audio')
+    /// </summary>
+    public IList<string>? InputModalities { get; set; }
+
+    /// <summary>
+    /// Output modalities the model can produce (e.g., 'text', 'audio')
+    /// </summary>
+    public IList<string>? OutputModalities { get; set; }
+
+    /// <summary>
+    /// Additional provider-specific properties
+    /// </summary>
+    public IDictionary<string, object>? AdditionalProperties { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ModelInfo instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ModelInfo instance.</returns>
+    public static ModelInfo Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ModelInfo();
+
+
+        if (data.TryGetValue("id", out var idValue) && idValue is not null)
+        {
+            instance.Id = idValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("displayName", out var displayNameValue) && displayNameValue is not null)
+        {
+            instance.DisplayName = displayNameValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("ownedBy", out var ownedByValue) && ownedByValue is not null)
+        {
+            instance.OwnedBy = ownedByValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("contextWindow", out var contextWindowValue) && contextWindowValue is not null)
+        {
+            instance.ContextWindow = Convert.ToInt32(contextWindowValue);
+        }
+
+        if (data.TryGetValue("inputModalities", out var inputModalitiesValue) && inputModalitiesValue is not null)
+        {
+            instance.InputModalities = (inputModalitiesValue as IEnumerable<object>)?.Select(x => x?.ToString()!).ToList() ?? [];
+        }
+
+        if (data.TryGetValue("outputModalities", out var outputModalitiesValue) && outputModalitiesValue is not null)
+        {
+            instance.OutputModalities = (outputModalitiesValue as IEnumerable<object>)?.Select(x => x?.ToString()!).ToList() ?? [];
+        }
+
+        if (data.TryGetValue("additionalProperties", out var additionalPropertiesValue) && additionalPropertiesValue is not null)
+        {
+            instance.AdditionalProperties = additionalPropertiesValue.GetDictionary()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ModelInfo instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["id"] = obj.Id;
+
+
+        if (obj.DisplayName is not null)
+        {
+            result["displayName"] = obj.DisplayName;
+        }
+
+
+        if (obj.OwnedBy is not null)
+        {
+            result["ownedBy"] = obj.OwnedBy;
+        }
+
+
+        if (obj.ContextWindow is not null)
+        {
+            result["contextWindow"] = obj.ContextWindow;
+        }
+
+
+        if (obj.InputModalities is not null)
+        {
+            result["inputModalities"] = obj.InputModalities;
+        }
+
+
+        if (obj.OutputModalities is not null)
+        {
+            result["outputModalities"] = obj.OutputModalities;
+        }
+
+
+        if (obj.AdditionalProperties is not null)
+        {
+            result["additionalProperties"] = obj.AdditionalProperties;
+        }
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ModelInfo instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ModelInfo instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ModelInfo instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ModelInfo instance.</returns>
+    public static ModelInfo FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ModelInfo instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ModelInfo instance.</returns>
+    public static ModelInfo FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ModelOptions.cs b/runtime/csharp/Prompty.Core/Model/ModelOptions.cs
index c22159c9..a2a9e173 100644
--- a/runtime/csharp/Prompty.Core/Model/ModelOptions.cs
+++ b/runtime/csharp/Prompty.Core/Model/ModelOptions.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// Options for configuring the behavior of the AI model.
 /// </summary>
-public class ModelOptions
+public partial class ModelOptions
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -76,6 +76,7 @@ public ModelOptions()
     public IDictionary<string, object>? AdditionalProperties { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -154,7 +155,6 @@ public static ModelOptions Load(Dictionary<string, object?> data, LoadContext? c
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -181,46 +181,55 @@ public static ModelOptions Load(Dictionary<string, object?> data, LoadContext? c
             result["frequencyPenalty"] = obj.FrequencyPenalty;
         }
 
+
         if (obj.MaxOutputTokens is not null)
         {
             result["maxOutputTokens"] = obj.MaxOutputTokens;
         }
 
+
         if (obj.PresencePenalty is not null)
         {
             result["presencePenalty"] = obj.PresencePenalty;
         }
 
+
         if (obj.Seed is not null)
         {
             result["seed"] = obj.Seed;
         }
 
+
         if (obj.Temperature is not null)
         {
             result["temperature"] = obj.Temperature;
         }
 
+
         if (obj.TopK is not null)
         {
             result["topK"] = obj.TopK;
         }
 
+
         if (obj.TopP is not null)
         {
             result["topP"] = obj.TopP;
         }
 
+
         if (obj.StopSequences is not null)
         {
             result["stopSequences"] = obj.StopSequences;
         }
 
+
         if (obj.AllowMultipleToolCalls is not null)
         {
             result["allowMultipleToolCalls"] = obj.AllowMultipleToolCalls;
         }
 
+
         if (obj.AdditionalProperties is not null)
         {
             result["additionalProperties"] = obj.AdditionalProperties;
@@ -235,6 +244,35 @@ public static ModelOptions Load(Dictionary<string, object?> data, LoadContext? c
         return result;
     }
 
+    /// <summary>
+    /// Convert this instance to a provider-specific wire-format dictionary.
+    /// </summary>
+    /// <param name="provider">The provider name (e.g., "openai", "anthropic").</param>
+    /// <returns>A dictionary with provider-specific field names.</returns>
+    public Dictionary<string, object?> ToWire(string provider)
+    {
+        var data = Save();
+        var result = new Dictionary<string, object?>();
+        var wireMap = new Dictionary<string, Dictionary<string, string>>
+        {
+            ["frequencyPenalty"] = new Dictionary<string, string> { ["openai"] = "frequency_penalty" },
+            ["maxOutputTokens"] = new Dictionary<string, string> { ["openai"] = "max_completion_tokens", ["responses"] = "max_output_tokens", ["anthropic"] = "max_tokens" },
+            ["presencePenalty"] = new Dictionary<string, string> { ["openai"] = "presence_penalty" },
+            ["seed"] = new Dictionary<string, string> { ["openai"] = "seed" },
+            ["temperature"] = new Dictionary<string, string> { ["openai"] = "temperature", ["responses"] = "temperature", ["anthropic"] = "temperature" },
+            ["topK"] = new Dictionary<string, string> { ["openai"] = "top_k", ["anthropic"] = "top_k" },
+            ["topP"] = new Dictionary<string, string> { ["openai"] = "top_p", ["responses"] = "top_p", ["anthropic"] = "top_p" },
+            ["stopSequences"] = new Dictionary<string, string> { ["openai"] = "stop", ["anthropic"] = "stop_sequences" },
+            ["allowMultipleToolCalls"] = new Dictionary<string, string> { ["openai"] = "parallel_tool_calls" },
+        };
+        foreach (var (key, value) in data)
+        {
+            if (wireMap.TryGetValue(key, out var mapping) && mapping.TryGetValue(provider, out var wireName))
+                result[wireName] = value;
+        }
+        return result;
+    }
+
 
     /// <summary>
     /// Convert the ModelOptions instance to a YAML string.
diff --git a/runtime/csharp/Prompty.Core/Model/OAuthConnection.cs b/runtime/csharp/Prompty.Core/Model/OAuthConnection.cs
index 6b1a94ed..bf557755 100644
--- a/runtime/csharp/Prompty.Core/Model/OAuthConnection.cs
+++ b/runtime/csharp/Prompty.Core/Model/OAuthConnection.cs
@@ -8,10 +8,12 @@ namespace Prompty.Core;
 
 /// <summary>
 /// Connection configuration using OAuth 2.0 client credentials.
+/// 
 /// Useful for tools and services that require OAuth authentication,
+/// 
 /// such as MCP servers, OpenAPI endpoints, or other REST APIs.
 /// </summary>
-public class OAuthConnection : Connection
+public partial class OAuthConnection : Connection
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -58,6 +60,7 @@ public OAuthConnection()
     public IList<string>? Scopes { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -116,7 +119,6 @@ public OAuthConnection()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -139,30 +141,20 @@ public OAuthConnection()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Endpoint is not null)
-        {
-            result["endpoint"] = obj.Endpoint;
-        }
 
-        if (obj.ClientId is not null)
-        {
-            result["clientId"] = obj.ClientId;
-        }
+        result["endpoint"] = obj.Endpoint;
 
-        if (obj.ClientSecret is not null)
-        {
-            result["clientSecret"] = obj.ClientSecret;
-        }
 
-        if (obj.TokenUrl is not null)
-        {
-            result["tokenUrl"] = obj.TokenUrl;
-        }
+        result["clientId"] = obj.ClientId;
+
+
+        result["clientSecret"] = obj.ClientSecret;
+
+
+        result["tokenUrl"] = obj.TokenUrl;
+
 
         if (obj.Scopes is not null)
         {
diff --git a/runtime/csharp/Prompty.Core/Model/ObjectProperty.cs b/runtime/csharp/Prompty.Core/Model/ObjectProperty.cs
index 4bb6ee0d..1ef8f5cf 100644
--- a/runtime/csharp/Prompty.Core/Model/ObjectProperty.cs
+++ b/runtime/csharp/Prompty.Core/Model/ObjectProperty.cs
@@ -8,9 +8,10 @@ namespace Prompty.Core;
 
 /// <summary>
 /// Represents an object property.
+/// 
 /// This extends the base Property model to represent a structured object.
 /// </summary>
-public class ObjectProperty : Property
+public partial class ObjectProperty : Property
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -27,7 +28,7 @@ public ObjectProperty()
 #pragma warning restore CS8618
 
     /// <summary>
-    /// 
+    /// Kind
     /// </summary>
     public override string Kind { get; set; } = "object";
 
@@ -37,6 +38,7 @@ public ObjectProperty()
     public IList<Property> Properties { get; set; } = [];
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -129,7 +131,6 @@ public static IList<Property> LoadProperties(object data, LoadContext? context)
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -152,15 +153,10 @@ public static IList<Property> LoadProperties(object data, LoadContext? context)
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Properties is not null)
-        {
-            result["properties"] = SaveProperties(obj.Properties, context);
-        }
+
+        result["properties"] = SaveProperties(obj.Properties, context);
 
 
         return result;
diff --git a/runtime/csharp/Prompty.Core/Model/OpenApiTool.cs b/runtime/csharp/Prompty.Core/Model/OpenApiTool.cs
index f1f8d0da..b895d92b 100644
--- a/runtime/csharp/Prompty.Core/Model/OpenApiTool.cs
+++ b/runtime/csharp/Prompty.Core/Model/OpenApiTool.cs
@@ -7,9 +7,8 @@ namespace Prompty.Core;
 #pragma warning restore IDE0130
 
 /// <summary>
-/// 
 /// </summary>
-public class OpenApiTool : Tool
+public partial class OpenApiTool : Tool
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -41,6 +40,7 @@ public OpenApiTool()
     public string Specification { get; set; } = string.Empty;
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -84,7 +84,6 @@ public OpenApiTool()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -107,20 +106,13 @@ public OpenApiTool()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Connection is not null)
-        {
-            result["connection"] = obj.Connection?.Save(context);
-        }
 
-        if (obj.Specification is not null)
-        {
-            result["specification"] = obj.Specification;
-        }
+        result["connection"] = obj.Connection?.Save(context);
+
+
+        result["specification"] = obj.Specification;
 
 
         return result;
diff --git a/runtime/csharp/Prompty.Core/Model/Parser.cs b/runtime/csharp/Prompty.Core/Model/Parser.cs
new file mode 100644
index 00000000..c70c01fb
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/Parser.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Parses rendered prompt text into an array of structured messages with role markers.
+/// </summary>
+public interface IParser
+{
+    /// <summary>
+    /// Pre-process a template before rendering, returning modified template and context
+    /// </summary>
+    object? PreRender(string template) => default;
+    /// <summary>
+    /// Parse rendered text into a structured message array
+    /// </summary>
+    Task<List<Message>> ParseAsync(Prompty agent, string rendered, Dictionary<string, object?>? context);
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ParserConfig.cs b/runtime/csharp/Prompty.Core/Model/ParserConfig.cs
index 78854d8c..04616f9d 100644
--- a/runtime/csharp/Prompty.Core/Model/ParserConfig.cs
+++ b/runtime/csharp/Prompty.Core/Model/ParserConfig.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// Template parser definition
 /// </summary>
-public class ParserConfig
+public partial class ParserConfig
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -36,6 +36,7 @@ public ParserConfig()
     public IDictionary<string, object>? Options { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -53,7 +54,6 @@ public static ParserConfig Load(Dictionary<string, object?> data, LoadContext? c
 
         // Note: Alternate (shorthand) representations are handled by the converter
 
-
         // Create new instance
         var instance = new ParserConfig();
 
@@ -76,7 +76,6 @@ public static ParserConfig Load(Dictionary<string, object?> data, LoadContext? c
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -98,10 +97,8 @@ public static ParserConfig Load(Dictionary<string, object?> data, LoadContext? c
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
+
 
         if (obj.Options is not null)
         {
diff --git a/runtime/csharp/Prompty.Core/Model/Processor.cs b/runtime/csharp/Prompty.Core/Model/Processor.cs
new file mode 100644
index 00000000..c9d42f2d
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/Processor.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Extracts a clean, typed result from a raw LLM provider response.
+/// </summary>
+public interface IProcessor
+{
+    /// <summary>
+    /// Extract a clean result from a raw LLM response
+    /// </summary>
+    Task<object> ProcessAsync(Prompty agent, object response);
+    /// <summary>
+    /// Process a streaming response into a stream of StreamChunk items. Takes raw chunks from the executor and yields processed text, thinking, tool, or error chunks. Not all providers support streaming; the default implementation should signal lack of support.
+    /// </summary>
+    Task<object> ProcessStreamAsync(object stream) => Task.FromResult<object>(default);
+}
diff --git a/runtime/csharp/Prompty.Core/Model/Prompty.cs b/runtime/csharp/Prompty.Core/Model/Prompty.cs
index c0ded05e..e5e2a6d3 100644
--- a/runtime/csharp/Prompty.Core/Model/Prompty.cs
+++ b/runtime/csharp/Prompty.Core/Model/Prompty.cs
@@ -8,13 +8,16 @@ namespace Prompty.Core;
 
 /// <summary>
 /// A Prompty is a markdown file format for LLM prompts. The frontmatter defines
+/// 
 /// structured metadata including model configuration, input/output schemas, tools,
+/// 
 /// and template settings. The markdown body becomes the instructions.
 /// 
 /// This is the single root type for the Prompty schema — there is no abstract base
+/// 
 /// class or kind discriminator. A .prompty file always produces a Prompty instance.
 /// </summary>
-public class Prompty
+public partial class Prompty
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -81,6 +84,7 @@ public Prompty()
     public string? Instructions { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -299,7 +303,7 @@ public static IList<Tool> LoadTools(object data, LoadContext? context)
                     var newDict = new Dictionary<string, object?>
                     {
                         ["name"] = kvp.Key,
-                        [""] = kvp.Value
+                        ["kind"] = kvp.Value
                     };
                     result.Add(Tool.Load(newDict, context));
                 }
@@ -321,7 +325,6 @@ public static IList<Tool> LoadTools(object data, LoadContext? context)
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -343,51 +346,54 @@ public static IList<Tool> LoadTools(object data, LoadContext? context)
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Name is not null)
-        {
-            result["name"] = obj.Name;
-        }
+        result["name"] = obj.Name;
+
 
         if (obj.DisplayName is not null)
         {
             result["displayName"] = obj.DisplayName;
         }
 
+
         if (obj.Description is not null)
         {
             result["description"] = obj.Description;
         }
 
+
         if (obj.Metadata is not null)
         {
             result["metadata"] = obj.Metadata;
         }
 
+
         if (obj.Inputs is not null)
         {
             result["inputs"] = SaveInputs(obj.Inputs, context);
         }
 
+
         if (obj.Outputs is not null)
         {
             result["outputs"] = SaveOutputs(obj.Outputs, context);
         }
 
-        if (obj.Model is not null)
-        {
-            result["model"] = obj.Model?.Save(context);
-        }
+
+        result["model"] = obj.Model?.Save(context);
+
 
         if (obj.Tools is not null)
         {
             result["tools"] = SaveTools(obj.Tools, context);
         }
 
+
         if (obj.Template is not null)
         {
             result["template"] = obj.Template?.Save(context);
         }
 
+
         if (obj.Instructions is not null)
         {
             result["instructions"] = obj.Instructions;
@@ -454,39 +460,8 @@ public static object SaveOutputs(IList<Property> items, SaveContext? context)
     {
         context ??= new SaveContext();
 
-
-        if (context.CollectionFormat == "array")
-        {
-            return items.Select(item => item.Save(context)).ToList();
-        }
-
-        // Object format: use name as key
-        var result = new Dictionary<string, object?>();
-        foreach (var item in items)
-        {
-            var itemData = item.Save(context);
-            if (itemData.TryGetValue("name", out var nameValue) && nameValue is string name)
-            {
-                itemData.Remove("name");
-
-                // Check if we can use shorthand
-                if (context.UseShorthand && Property.ShorthandProperty is string shorthandProp)
-                {
-                    if (itemData.Count == 1 && itemData.ContainsKey(shorthandProp))
-                    {
-                        result[name] = itemData[shorthandProp];
-                        continue;
-                    }
-                }
-                result[name] = itemData;
-            }
-            else
-            {
-                // No name, can't use object format for this item
-                throw new InvalidOperationException("Cannot save item in object format: missing 'name' property");
-            }
-        }
-        return result;
+        // This collection type does not have a 'name' property, only array format is supported
+        return items.Select(item => item.Save(context)).ToList();
 
     }
 
diff --git a/runtime/csharp/Prompty.Core/Model/PromptyTool.cs b/runtime/csharp/Prompty.Core/Model/PromptyTool.cs
index 7307bada..0c828f2b 100644
--- a/runtime/csharp/Prompty.Core/Model/PromptyTool.cs
+++ b/runtime/csharp/Prompty.Core/Model/PromptyTool.cs
@@ -10,9 +10,10 @@ namespace Prompty.Core;
 /// A tool that references another .prompty file to be invoked as a tool.
 /// 
 /// In `single` mode, the child prompty is executed with a single LLM call.
+/// 
 /// In `agentic` mode, the child prompty runs a full agent loop with its own tools.
 /// </summary>
-public class PromptyTool : Tool
+public partial class PromptyTool : Tool
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -44,6 +45,7 @@ public PromptyTool()
     public string Mode { get; set; } = "single";
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -87,7 +89,6 @@ public PromptyTool()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -110,20 +111,13 @@ public PromptyTool()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Path is not null)
-        {
-            result["path"] = obj.Path;
-        }
 
-        if (obj.Mode is not null)
-        {
-            result["mode"] = obj.Mode;
-        }
+        result["path"] = obj.Path;
+
+
+        result["mode"] = obj.Mode;
 
 
         return result;
diff --git a/runtime/csharp/Prompty.Core/Model/Property.cs b/runtime/csharp/Prompty.Core/Model/Property.cs
index 12b87238..38ac93a6 100644
--- a/runtime/csharp/Prompty.Core/Model/Property.cs
+++ b/runtime/csharp/Prompty.Core/Model/Property.cs
@@ -10,11 +10,14 @@ namespace Prompty.Core;
 /// Represents a single property.
 /// 
 /// - This model defines the structure of properties that can be used in prompts,
+/// 
 /// including their type, description, whether they are required, and other attributes.
+/// 
 /// - It allows for the definition of dynamic inputs that can be filled with data
+/// 
 /// and processed to generate prompts for AI models.
 /// </summary>
-public class Property
+public partial class Property
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -66,6 +69,7 @@ public Property()
     public IList<object>? EnumValues { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -83,7 +87,6 @@ public static Property Load(Dictionary<string, object?> data, LoadContext? conte
 
         // Note: Alternate (shorthand) representations are handled by the converter
 
-
         // Load polymorphic Property instance
         var instance = LoadKind(data, context);
 
@@ -131,7 +134,6 @@ public static Property Load(Dictionary<string, object?> data, LoadContext? conte
     }
 
 
-
     /// <summary>
     /// Load polymorphic Property based on discriminator.
     /// </summary>
@@ -174,36 +176,36 @@ private static Property LoadKind(Dictionary<string, object?> data, LoadContext?
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Name is not null)
-        {
-            result["name"] = obj.Name;
-        }
+        result["name"] = obj.Name;
+
+
+        result["kind"] = obj.Kind;
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
 
         if (obj.Description is not null)
         {
             result["description"] = obj.Description;
         }
 
+
         if (obj.Required is not null)
         {
             result["required"] = obj.Required;
         }
 
+
         if (obj.Default is not null)
         {
             result["default"] = obj.Default;
         }
 
+
         if (obj.Example is not null)
         {
             result["example"] = obj.Example;
         }
 
+
         if (obj.EnumValues is not null)
         {
             result["enumValues"] = obj.EnumValues;
@@ -263,16 +265,16 @@ public static Property FromJson(string json, LoadContext? context = null)
                     ["kind"] = "boolean",
                     ["example"] = boolValue,
                 },
-                string stringValue => new Dictionary<string, object?>
-                {
-                    ["kind"] = "string",
-                    ["example"] = stringValue,
-                },
                 float floatValue => new Dictionary<string, object?>
                 {
                     ["kind"] = "float",
                     ["example"] = floatValue,
                 },
+                double doubleValue => new Dictionary<string, object?>
+                {
+                    ["kind"] = "float",
+                    ["example"] = doubleValue,
+                },
                 int intValue => new Dictionary<string, object?>
                 {
                     ["kind"] = "integer",
@@ -283,10 +285,10 @@ public static Property FromJson(string json, LoadContext? context = null)
                     ["kind"] = "integer",
                     ["example"] = longValue,
                 },
-                double doubleValue => new Dictionary<string, object?>
+                string stringValue => new Dictionary<string, object?>
                 {
-                    ["kind"] = "float",
-                    ["example"] = doubleValue,
+                    ["kind"] = "string",
+                    ["example"] = stringValue,
                 },
                 _ => new Dictionary<string, object?>
                 {
@@ -338,16 +340,16 @@ public static Property FromYaml(string yaml, LoadContext? context = null)
                     ["kind"] = "boolean",
                     ["example"] = boolValue,
                 },
-                string stringValue => new Dictionary<string, object?>
-                {
-                    ["kind"] = "string",
-                    ["example"] = stringValue,
-                },
                 float floatValue => new Dictionary<string, object?>
                 {
                     ["kind"] = "float",
                     ["example"] = floatValue,
                 },
+                double doubleValue => new Dictionary<string, object?>
+                {
+                    ["kind"] = "float",
+                    ["example"] = doubleValue,
+                },
                 int intValue => new Dictionary<string, object?>
                 {
                     ["kind"] = "integer",
@@ -358,10 +360,10 @@ public static Property FromYaml(string yaml, LoadContext? context = null)
                     ["kind"] = "integer",
                     ["example"] = longValue,
                 },
-                double doubleValue => new Dictionary<string, object?>
+                string stringValue => new Dictionary<string, object?>
                 {
-                    ["kind"] = "float",
-                    ["example"] = doubleValue,
+                    ["kind"] = "string",
+                    ["example"] = stringValue,
                 },
                 _ => new Dictionary<string, object?>
                 {
diff --git a/runtime/csharp/Prompty.Core/Model/ReferenceConnection.cs b/runtime/csharp/Prompty.Core/Model/ReferenceConnection.cs
index eedd0d30..6df6fe5a 100644
--- a/runtime/csharp/Prompty.Core/Model/ReferenceConnection.cs
+++ b/runtime/csharp/Prompty.Core/Model/ReferenceConnection.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// Connection configuration for AI services using named connections.
 /// </summary>
-public class ReferenceConnection : Connection
+public partial class ReferenceConnection : Connection
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -41,6 +41,7 @@ public ReferenceConnection()
     public string? Target { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -84,7 +85,6 @@ public ReferenceConnection()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -107,15 +107,11 @@ public ReferenceConnection()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
+
+
+        result["name"] = obj.Name;
 
-        if (obj.Name is not null)
-        {
-            result["name"] = obj.Name;
-        }
 
         if (obj.Target is not null)
         {
diff --git a/runtime/csharp/Prompty.Core/Model/RemoteConnection.cs b/runtime/csharp/Prompty.Core/Model/RemoteConnection.cs
index 90c6e617..d94c4763 100644
--- a/runtime/csharp/Prompty.Core/Model/RemoteConnection.cs
+++ b/runtime/csharp/Prompty.Core/Model/RemoteConnection.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// Connection configuration for AI services using named connections.
 /// </summary>
-public class RemoteConnection : Connection
+public partial class RemoteConnection : Connection
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -41,6 +41,7 @@ public RemoteConnection()
     public string Endpoint { get; set; } = string.Empty;
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -84,7 +85,6 @@ public RemoteConnection()
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -107,20 +107,13 @@ public RemoteConnection()
         var result = base.Save(context);
 
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
+        result["kind"] = obj.Kind;
 
-        if (obj.Name is not null)
-        {
-            result["name"] = obj.Name;
-        }
 
-        if (obj.Endpoint is not null)
-        {
-            result["endpoint"] = obj.Endpoint;
-        }
+        result["name"] = obj.Name;
+
+
+        result["endpoint"] = obj.Endpoint;
 
 
         return result;
diff --git a/runtime/csharp/Prompty.Core/Model/Renderer.cs b/runtime/csharp/Prompty.Core/Model/Renderer.cs
new file mode 100644
index 00000000..67682679
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/Renderer.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Renders a template string with input values to produce the final prompt text.
+/// </summary>
+public interface IRenderer
+{
+    /// <summary>
+    /// Render the template string with input values
+    /// </summary>
+    Task<string> RenderAsync(Prompty agent, string template, Dictionary<string, object?> inputs);
+}
diff --git a/runtime/csharp/Prompty.Core/Model/StatusEventPayload.cs b/runtime/csharp/Prompty.Core/Model/StatusEventPayload.cs
new file mode 100644
index 00000000..a1372eaf
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/StatusEventPayload.cs
@@ -0,0 +1,155 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "status" events — informational messages about loop progress.
+/// </summary>
+public partial class StatusEventPayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="StatusEventPayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public StatusEventPayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// Human-readable status message
+    /// </summary>
+    public string Message { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a StatusEventPayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded StatusEventPayload instance.</returns>
+    public static StatusEventPayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new StatusEventPayload();
+
+
+        if (data.TryGetValue("message", out var messageValue) && messageValue is not null)
+        {
+            instance.Message = messageValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the StatusEventPayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["message"] = obj.Message;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the StatusEventPayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the StatusEventPayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a StatusEventPayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded StatusEventPayload instance.</returns>
+    public static StatusEventPayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a StatusEventPayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded StatusEventPayload instance.</returns>
+    public static StatusEventPayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/StreamChunk.cs b/runtime/csharp/Prompty.Core/Model/StreamChunk.cs
new file mode 100644
index 00000000..2fcc0b9d
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/StreamChunk.cs
@@ -0,0 +1,180 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// A chunk of data from a streaming LLM response. Stream chunks are
+/// 
+/// discriminated on the `kind` field.
+/// </summary>
+public abstract partial class StreamChunk
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="StreamChunk"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    protected StreamChunk()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind of stream chunk
+    /// </summary>
+    public virtual string Kind { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a StreamChunk instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded StreamChunk instance.</returns>
+    public static StreamChunk Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Load polymorphic StreamChunk instance
+        var instance = LoadKind(data, context);
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    /// <summary>
+    /// Load polymorphic StreamChunk based on discriminator.
+    /// </summary>
+    private static StreamChunk LoadKind(Dictionary<string, object?> data, LoadContext? context)
+    {
+        if (data.TryGetValue("kind", out var discriminatorValue) && discriminatorValue is not null)
+        {
+            var discriminator = discriminatorValue.ToString()?.ToLowerInvariant();
+            return discriminator switch
+            {
+                "text" => TextChunk.Load(data, context),
+                "thinking" => ThinkingChunk.Load(data, context),
+                "tool" => ToolChunk.Load(data, context),
+                "error" => ErrorChunk.Load(data, context),
+                _ => throw new ArgumentException($"Unknown StreamChunk discriminator value: {discriminator}"),
+            };
+        }
+
+        throw new ArgumentException("Missing StreamChunk discriminator property: 'kind'");
+
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the StreamChunk instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public virtual Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["kind"] = obj.Kind;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the StreamChunk instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the StreamChunk instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a StreamChunk instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded StreamChunk instance.</returns>
+    public static StreamChunk FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a StreamChunk instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded StreamChunk instance.</returns>
+    public static StreamChunk FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/Template.cs b/runtime/csharp/Prompty.Core/Model/Template.cs
index c356d8c5..2484a19c 100644
--- a/runtime/csharp/Prompty.Core/Model/Template.cs
+++ b/runtime/csharp/Prompty.Core/Model/Template.cs
@@ -10,13 +10,16 @@ namespace Prompty.Core;
 /// Template model for defining prompt templates.
 /// 
 /// This model specifies the rendering engine used for slot filling prompts,
+/// 
 /// the parser used to process the rendered template into API-compatible format,
+/// 
 /// and additional options for the template engine.
 /// 
 /// It allows for the creation of reusable templates that can be filled with dynamic data
+/// 
 /// and processed to generate prompts for AI models.
 /// </summary>
-public class Template
+public partial class Template
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -43,6 +46,7 @@ public Template()
     public ParserConfig Parser { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -81,7 +85,6 @@ public static Template Load(Dictionary<string, object?> data, LoadContext? conte
     }
 
 
-
     #endregion
 
     #region Save Methods
@@ -103,15 +106,10 @@ public static Template Load(Dictionary<string, object?> data, LoadContext? conte
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Format is not null)
-        {
-            result["format"] = obj.Format?.Save(context);
-        }
+        result["format"] = obj.Format?.Save(context);
 
-        if (obj.Parser is not null)
-        {
-            result["parser"] = obj.Parser?.Save(context);
-        }
+
+        result["parser"] = obj.Parser?.Save(context);
 
 
         if (context is not null)
diff --git a/runtime/csharp/Prompty.Core/Model/TextChunk.cs b/runtime/csharp/Prompty.Core/Model/TextChunk.cs
new file mode 100644
index 00000000..12cce412
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/TextChunk.cs
@@ -0,0 +1,164 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// A text content chunk from the LLM response stream.
+/// </summary>
+public partial class TextChunk : StreamChunk
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public new static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="TextChunk"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public TextChunk()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind identifier for text chunks
+    /// </summary>
+    public override string Kind { get; set; } = "text";
+
+    /// <summary>
+    /// The text content of the chunk
+    /// </summary>
+    public string Value { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a TextChunk instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TextChunk instance.</returns>
+    public new static TextChunk Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new TextChunk();
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("value", out var valueValue) && valueValue is not null)
+        {
+            instance.Value = valueValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the TextChunk instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public override Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        // Start with parent class properties
+        var result = base.Save(context);
+
+
+        result["kind"] = obj.Kind;
+
+
+        result["value"] = obj.Value;
+
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the TextChunk instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public new string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the TextChunk instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public new string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a TextChunk instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TextChunk instance.</returns>
+    public new static TextChunk FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a TextChunk instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TextChunk instance.</returns>
+    public new static TextChunk FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/TextPart.cs b/runtime/csharp/Prompty.Core/Model/TextPart.cs
new file mode 100644
index 00000000..ef0d1dc3
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/TextPart.cs
@@ -0,0 +1,164 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// A text content part.
+/// </summary>
+public partial class TextPart : ContentPart
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public new static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="TextPart"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public TextPart()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind identifier for text content
+    /// </summary>
+    public override string Kind { get; set; } = "text";
+
+    /// <summary>
+    /// The text content
+    /// </summary>
+    public string Value { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a TextPart instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TextPart instance.</returns>
+    public new static TextPart Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new TextPart();
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("value", out var valueValue) && valueValue is not null)
+        {
+            instance.Value = valueValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the TextPart instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public override Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        // Start with parent class properties
+        var result = base.Save(context);
+
+
+        result["kind"] = obj.Kind;
+
+
+        result["value"] = obj.Value;
+
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the TextPart instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public new string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the TextPart instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public new string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a TextPart instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TextPart instance.</returns>
+    public new static TextPart FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a TextPart instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TextPart instance.</returns>
+    public new static TextPart FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ThinkingChunk.cs b/runtime/csharp/Prompty.Core/Model/ThinkingChunk.cs
new file mode 100644
index 00000000..a75d4497
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ThinkingChunk.cs
@@ -0,0 +1,164 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// A thinking/reasoning content chunk from the LLM response stream.
+/// </summary>
+public partial class ThinkingChunk : StreamChunk
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public new static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ThinkingChunk"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ThinkingChunk()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind identifier for thinking chunks
+    /// </summary>
+    public override string Kind { get; set; } = "thinking";
+
+    /// <summary>
+    /// The thinking content of the chunk
+    /// </summary>
+    public string Value { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ThinkingChunk instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ThinkingChunk instance.</returns>
+    public new static ThinkingChunk Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ThinkingChunk();
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("value", out var valueValue) && valueValue is not null)
+        {
+            instance.Value = valueValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ThinkingChunk instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public override Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        // Start with parent class properties
+        var result = base.Save(context);
+
+
+        result["kind"] = obj.Kind;
+
+
+        result["value"] = obj.Value;
+
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ThinkingChunk instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public new string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ThinkingChunk instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public new string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ThinkingChunk instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ThinkingChunk instance.</returns>
+    public new static ThinkingChunk FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ThinkingChunk instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ThinkingChunk instance.</returns>
+    public new static ThinkingChunk FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ThinkingEventPayload.cs b/runtime/csharp/Prompty.Core/Model/ThinkingEventPayload.cs
new file mode 100644
index 00000000..15ec5cbc
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ThinkingEventPayload.cs
@@ -0,0 +1,155 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "thinking" events — reasoning/chain-of-thought tokens.
+/// </summary>
+public partial class ThinkingEventPayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ThinkingEventPayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ThinkingEventPayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The thinking/reasoning token text
+    /// </summary>
+    public string Token { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ThinkingEventPayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ThinkingEventPayload instance.</returns>
+    public static ThinkingEventPayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ThinkingEventPayload();
+
+
+        if (data.TryGetValue("token", out var tokenValue) && tokenValue is not null)
+        {
+            instance.Token = tokenValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ThinkingEventPayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["token"] = obj.Token;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ThinkingEventPayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ThinkingEventPayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ThinkingEventPayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ThinkingEventPayload instance.</returns>
+    public static ThinkingEventPayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ThinkingEventPayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ThinkingEventPayload instance.</returns>
+    public static ThinkingEventPayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ThreadMarker.cs b/runtime/csharp/Prompty.Core/Model/ThreadMarker.cs
new file mode 100644
index 00000000..7cf74f85
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ThreadMarker.cs
@@ -0,0 +1,174 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Positional marker for conversation history insertion during template rendering.
+/// 
+/// During `prepare()`, nonce strings in rendered text are replaced with
+/// 
+/// ThreadMarker objects. The pipeline then replaces them with actual
+/// 
+/// conversation messages from the inputs.
+/// </summary>
+public partial class ThreadMarker
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ThreadMarker"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ThreadMarker()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The input property name (e.g. 'conversation')
+    /// </summary>
+    public string Name { get; set; } = "thread";
+
+    /// <summary>
+    /// The rich kind ('thread', 'image', 'file', 'audio')
+    /// </summary>
+    public string Kind { get; set; } = "thread";
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ThreadMarker instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ThreadMarker instance.</returns>
+    public static ThreadMarker Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ThreadMarker();
+
+
+        if (data.TryGetValue("name", out var nameValue) && nameValue is not null)
+        {
+            instance.Name = nameValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ThreadMarker instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["name"] = obj.Name;
+
+
+        result["kind"] = obj.Kind;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ThreadMarker instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ThreadMarker instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ThreadMarker instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ThreadMarker instance.</returns>
+    public static ThreadMarker FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ThreadMarker instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ThreadMarker instance.</returns>
+    public static ThreadMarker FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/TokenEventPayload.cs b/runtime/csharp/Prompty.Core/Model/TokenEventPayload.cs
new file mode 100644
index 00000000..46d720e0
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/TokenEventPayload.cs
@@ -0,0 +1,155 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "token" events — a single text token streamed from the LLM.
+/// </summary>
+public partial class TokenEventPayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="TokenEventPayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public TokenEventPayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The streamed token text
+    /// </summary>
+    public string Token { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a TokenEventPayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TokenEventPayload instance.</returns>
+    public static TokenEventPayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new TokenEventPayload();
+
+
+        if (data.TryGetValue("token", out var tokenValue) && tokenValue is not null)
+        {
+            instance.Token = tokenValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the TokenEventPayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["token"] = obj.Token;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the TokenEventPayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the TokenEventPayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a TokenEventPayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TokenEventPayload instance.</returns>
+    public static TokenEventPayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a TokenEventPayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TokenEventPayload instance.</returns>
+    public static TokenEventPayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/TokenUsage.cs b/runtime/csharp/Prompty.Core/Model/TokenUsage.cs
new file mode 100644
index 00000000..ace9cff2
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/TokenUsage.cs
@@ -0,0 +1,217 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Tracks token consumption for a single LLM call. Provider-specific field
+/// 
+/// names (e.g., OpenAI's `prompt_tokens` vs Anthropic's `input_tokens`)
+/// 
+/// are mapped via `knownAs` augments in the wire directory.
+/// </summary>
+public partial class TokenUsage
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="TokenUsage"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public TokenUsage()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// Number of tokens in the prompt/input sent to the model
+    /// </summary>
+    public int? PromptTokens { get; set; }
+
+    /// <summary>
+    /// Number of tokens generated in the model's completion/output
+    /// </summary>
+    public int? CompletionTokens { get; set; }
+
+    /// <summary>
+    /// Total tokens consumed (prompt + completion). May be provided by the API or computed.
+    /// </summary>
+    public int? TotalTokens { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a TokenUsage instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TokenUsage instance.</returns>
+    public static TokenUsage Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new TokenUsage();
+
+
+        if (data.TryGetValue("promptTokens", out var promptTokensValue) && promptTokensValue is not null)
+        {
+            instance.PromptTokens = Convert.ToInt32(promptTokensValue);
+        }
+
+        if (data.TryGetValue("completionTokens", out var completionTokensValue) && completionTokensValue is not null)
+        {
+            instance.CompletionTokens = Convert.ToInt32(completionTokensValue);
+        }
+
+        if (data.TryGetValue("totalTokens", out var totalTokensValue) && totalTokensValue is not null)
+        {
+            instance.TotalTokens = Convert.ToInt32(totalTokensValue);
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the TokenUsage instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        if (obj.PromptTokens is not null)
+        {
+            result["promptTokens"] = obj.PromptTokens;
+        }
+
+
+        if (obj.CompletionTokens is not null)
+        {
+            result["completionTokens"] = obj.CompletionTokens;
+        }
+
+
+        if (obj.TotalTokens is not null)
+        {
+            result["totalTokens"] = obj.TotalTokens;
+        }
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Convert this instance to a provider-specific wire-format dictionary.
+    /// </summary>
+    /// <param name="provider">The provider name (e.g., "openai", "anthropic").</param>
+    /// <returns>A dictionary with provider-specific field names.</returns>
+    public Dictionary<string, object?> ToWire(string provider)
+    {
+        var data = Save();
+        var result = new Dictionary<string, object?>();
+        var wireMap = new Dictionary<string, Dictionary<string, string>>
+        {
+            ["promptTokens"] = new Dictionary<string, string> { ["openai"] = "prompt_tokens", ["anthropic"] = "input_tokens" },
+            ["completionTokens"] = new Dictionary<string, string> { ["openai"] = "completion_tokens", ["anthropic"] = "output_tokens" },
+            ["totalTokens"] = new Dictionary<string, string> { ["openai"] = "total_tokens" },
+        };
+        foreach (var (key, value) in data)
+        {
+            if (wireMap.TryGetValue(key, out var mapping) && mapping.TryGetValue(provider, out var wireName))
+                result[wireName] = value;
+        }
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the TokenUsage instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the TokenUsage instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a TokenUsage instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TokenUsage instance.</returns>
+    public static TokenUsage FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a TokenUsage instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TokenUsage instance.</returns>
+    public static TokenUsage FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/Tool.cs b/runtime/csharp/Prompty.Core/Model/Tool.cs
index 6914f08b..3a19125c 100644
--- a/runtime/csharp/Prompty.Core/Model/Tool.cs
+++ b/runtime/csharp/Prompty.Core/Model/Tool.cs
@@ -9,7 +9,7 @@ namespace Prompty.Core;
 /// <summary>
 /// Represents a tool that can be used in prompts.
 /// </summary>
-public abstract class Tool
+public abstract partial class Tool
 {
     /// <summary>
     /// The shorthand property name for this type, if any.
@@ -46,6 +46,7 @@ protected Tool()
     public IList<Binding>? Bindings { get; set; }
 
 
+
     #region Load Methods
 
     /// <summary>
@@ -148,7 +149,6 @@ public static IList<Binding> LoadBindings(object data, LoadContext? context)
     }
 
 
-
     /// <summary>
     /// Load polymorphic Tool based on discriminator.
     /// </summary>
@@ -193,21 +193,18 @@ private static Tool LoadKind(Dictionary<string, object?> data, LoadContext? cont
         var result = new Dictionary<string, object?>();
 
 
-        if (obj.Name is not null)
-        {
-            result["name"] = obj.Name;
-        }
+        result["name"] = obj.Name;
+
+
+        result["kind"] = obj.Kind;
 
-        if (obj.Kind is not null)
-        {
-            result["kind"] = obj.Kind;
-        }
 
         if (obj.Description is not null)
         {
             result["description"] = obj.Description;
         }
 
+
         if (obj.Bindings is not null)
         {
             result["bindings"] = SaveBindings(obj.Bindings, context);
diff --git a/runtime/csharp/Prompty.Core/Model/ToolCall.cs b/runtime/csharp/Prompty.Core/Model/ToolCall.cs
new file mode 100644
index 00000000..4c68a00e
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ToolCall.cs
@@ -0,0 +1,183 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// A tool call requested by the LLM. Contains the function name and serialized
+/// 
+/// arguments that should be dispatched to the appropriate tool handler.
+/// </summary>
+public partial class ToolCall
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ToolCall"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ToolCall()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The unique identifier of the tool call
+    /// </summary>
+    public string Id { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The name of the tool to call
+    /// </summary>
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The serialized JSON arguments for the tool call
+    /// </summary>
+    public string Arguments { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ToolCall instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolCall instance.</returns>
+    public static ToolCall Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ToolCall();
+
+
+        if (data.TryGetValue("id", out var idValue) && idValue is not null)
+        {
+            instance.Id = idValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("name", out var nameValue) && nameValue is not null)
+        {
+            instance.Name = nameValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("arguments", out var argumentsValue) && argumentsValue is not null)
+        {
+            instance.Arguments = argumentsValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ToolCall instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["id"] = obj.Id;
+
+
+        result["name"] = obj.Name;
+
+
+        result["arguments"] = obj.Arguments;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ToolCall instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ToolCall instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ToolCall instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolCall instance.</returns>
+    public static ToolCall FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ToolCall instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolCall instance.</returns>
+    public static ToolCall FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ToolCallStartPayload.cs b/runtime/csharp/Prompty.Core/Model/ToolCallStartPayload.cs
new file mode 100644
index 00000000..7527106d
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ToolCallStartPayload.cs
@@ -0,0 +1,168 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "tool_call_start" events — the LLM has requested a tool call.
+/// </summary>
+public partial class ToolCallStartPayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ToolCallStartPayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ToolCallStartPayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The name of the tool being called
+    /// </summary>
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The serialized JSON arguments for the tool call
+    /// </summary>
+    public string Arguments { get; set; } = string.Empty;
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ToolCallStartPayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolCallStartPayload instance.</returns>
+    public static ToolCallStartPayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ToolCallStartPayload();
+
+
+        if (data.TryGetValue("name", out var nameValue) && nameValue is not null)
+        {
+            instance.Name = nameValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("arguments", out var argumentsValue) && argumentsValue is not null)
+        {
+            instance.Arguments = argumentsValue?.ToString()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ToolCallStartPayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["name"] = obj.Name;
+
+
+        result["arguments"] = obj.Arguments;
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ToolCallStartPayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ToolCallStartPayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ToolCallStartPayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolCallStartPayload instance.</returns>
+    public static ToolCallStartPayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ToolCallStartPayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolCallStartPayload instance.</returns>
+    public static ToolCallStartPayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ToolChunk.cs b/runtime/csharp/Prompty.Core/Model/ToolChunk.cs
new file mode 100644
index 00000000..ec25e197
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ToolChunk.cs
@@ -0,0 +1,164 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// A tool call chunk from the LLM response stream.
+/// </summary>
+public partial class ToolChunk : StreamChunk
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public new static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ToolChunk"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ToolChunk()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The kind identifier for tool chunks
+    /// </summary>
+    public override string Kind { get; set; } = "tool";
+
+    /// <summary>
+    /// The tool call data
+    /// </summary>
+    public ToolCall ToolCall { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ToolChunk instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolChunk instance.</returns>
+    public new static ToolChunk Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ToolChunk();
+
+
+        if (data.TryGetValue("kind", out var kindValue) && kindValue is not null)
+        {
+            instance.Kind = kindValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("toolCall", out var toolCallValue) && toolCallValue is not null)
+        {
+            instance.ToolCall = ToolCall.Load(toolCallValue.GetDictionary(ToolCall.ShorthandProperty), context);
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ToolChunk instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public override Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        // Start with parent class properties
+        var result = base.Save(context);
+
+
+        result["kind"] = obj.Kind;
+
+
+        result["toolCall"] = obj.ToolCall?.Save(context);
+
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ToolChunk instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public new string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ToolChunk instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public new string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ToolChunk instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolChunk instance.</returns>
+    public new static ToolChunk FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ToolChunk instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolChunk instance.</returns>
+    public new static ToolChunk FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ToolContext.cs b/runtime/csharp/Prompty.Core/Model/ToolContext.cs
new file mode 100644
index 00000000..7e7e3d72
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ToolContext.cs
@@ -0,0 +1,242 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Context passed to tool handlers during agent loop execution. Provides
+/// 
+/// access to the agent configuration, current conversation state, and
+/// 
+/// arbitrary metadata for tool implementations that need broader context.
+/// </summary>
+public partial class ToolContext
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ToolContext"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ToolContext()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The current conversation messages at the point of tool invocation
+    /// </summary>
+    public IList<Message> Messages { get; set; } = [];
+
+    /// <summary>
+    /// Optional metadata for tool-specific context (e.g., user session info)
+    /// </summary>
+    public IDictionary<string, object>? Metadata { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ToolContext instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolContext instance.</returns>
+    public static ToolContext Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ToolContext();
+
+
+        if (data.TryGetValue("messages", out var messagesValue) && messagesValue is not null)
+        {
+            instance.Messages = LoadMessages(messagesValue, context);
+        }
+
+        if (data.TryGetValue("metadata", out var metadataValue) && metadataValue is not null)
+        {
+            instance.Metadata = metadataValue.GetDictionary()!;
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    /// <summary>
+    /// Load a list of Message from a dictionary or list.
+    /// </summary>
+    public static IList<Message> LoadMessages(object data, LoadContext? context)
+    {
+        var result = new List<Message>();
+
+        if (data is Dictionary<string, object?> dict)
+        {
+            // Convert named dictionary to list
+            foreach (var kvp in dict)
+            {
+                if (kvp.Value is IEnumerable<object>)
+                {
+                    throw new ArgumentException(
+                        $"Invalid 'messages' format: key '{kvp.Key}' has an array value. " +
+                        $"'messages' must be a flat list of objects or a name-keyed dict — " +
+                        "not a nested {" + kvp.Key + ": [...]} structure.");
+                }
+                var itemDict = kvp.Value.GetDictionary();
+                if (itemDict.Count > 0)
+                {
+                    // Value is an object, add name to it
+                    itemDict["name"] = kvp.Key;
+                    result.Add(Message.Load(itemDict, context));
+                }
+                else
+                {
+                    // Value is a scalar, use it as the primary property
+                    var newDict = new Dictionary<string, object?>
+                    {
+                        ["name"] = kvp.Key,
+                        ["role"] = kvp.Value
+                    };
+                    result.Add(Message.Load(newDict, context));
+                }
+            }
+        }
+        else if (data is IEnumerable<object> list)
+        {
+            foreach (var item in list)
+            {
+                var itemDict = item.GetDictionary(Message.ShorthandProperty);
+                if (itemDict.Count > 0)
+                {
+                    result.Add(Message.Load(itemDict, context));
+                }
+            }
+        }
+
+        return result;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ToolContext instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["messages"] = SaveMessages(obj.Messages, context);
+
+
+        if (obj.Metadata is not null)
+        {
+            result["metadata"] = obj.Metadata;
+        }
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Save a list of Message to object or array format.
+    /// </summary>
+    public static object SaveMessages(IList<Message> items, SaveContext? context)
+    {
+        context ??= new SaveContext();
+
+        // This collection type does not have a 'name' property, only array format is supported
+        return items.Select(item => item.Save(context)).ToList();
+
+    }
+
+
+    /// <summary>
+    /// Convert the ToolContext instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ToolContext instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ToolContext instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolContext instance.</returns>
+    public static ToolContext FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ToolContext instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolContext instance.</returns>
+    public static ToolContext FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ToolDispatchResult.cs b/runtime/csharp/Prompty.Core/Model/ToolDispatchResult.cs
new file mode 100644
index 00000000..5fa86f43
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ToolDispatchResult.cs
@@ -0,0 +1,185 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// The result of dispatching a single tool call. Pairs the tool call
+/// 
+/// identifier with the tool's name and result for correlation in the
+/// 
+/// agent loop's message assembly.
+/// </summary>
+public partial class ToolDispatchResult
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ToolDispatchResult"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ToolDispatchResult()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The tool call ID from the LLM response, used to correlate results
+    /// </summary>
+    public string ToolCallId { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The name of the tool that was called
+    /// </summary>
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The result produced by the tool handler
+    /// </summary>
+    public ToolResult Result { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ToolDispatchResult instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolDispatchResult instance.</returns>
+    public static ToolDispatchResult Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ToolDispatchResult();
+
+
+        if (data.TryGetValue("toolCallId", out var toolCallIdValue) && toolCallIdValue is not null)
+        {
+            instance.ToolCallId = toolCallIdValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("name", out var nameValue) && nameValue is not null)
+        {
+            instance.Name = nameValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("result", out var resultValue) && resultValue is not null)
+        {
+            instance.Result = ToolResult.Load(resultValue.GetDictionary(ToolResult.ShorthandProperty), context);
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ToolDispatchResult instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["toolCallId"] = obj.ToolCallId;
+
+
+        result["name"] = obj.Name;
+
+
+        result["result"] = obj.Result?.Save(context);
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ToolDispatchResult instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ToolDispatchResult instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ToolDispatchResult instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolDispatchResult instance.</returns>
+    public static ToolDispatchResult FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ToolDispatchResult instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolDispatchResult instance.</returns>
+    public static ToolDispatchResult FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ToolResult.cs b/runtime/csharp/Prompty.Core/Model/ToolResult.cs
new file mode 100644
index 00000000..9f045d87
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ToolResult.cs
@@ -0,0 +1,255 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// The result of a tool execution. Contains a list of content parts, enabling
+/// 
+/// rich tool results (text, images, files, audio) rather than just strings.
+/// 
+/// Implementations MUST support conversion from a plain string to a ToolResult
+/// 
+/// containing a single TextPart for backward compatibility.
+/// </summary>
+public partial class ToolResult : IToolResultHelpers
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ToolResult"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ToolResult()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The content parts of the tool result
+    /// </summary>
+    public IList<ContentPart> Parts { get; set; } = [];
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ToolResult instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolResult instance.</returns>
+    public static ToolResult Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ToolResult();
+
+
+        if (data.TryGetValue("parts", out var partsValue) && partsValue is not null)
+        {
+            instance.Parts = LoadParts(partsValue, context);
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    /// <summary>
+    /// Load a list of ContentPart from a dictionary or list.
+    /// </summary>
+    public static IList<ContentPart> LoadParts(object data, LoadContext? context)
+    {
+        var result = new List<ContentPart>();
+
+        if (data is Dictionary<string, object?> dict)
+        {
+            // Convert named dictionary to list
+            foreach (var kvp in dict)
+            {
+                if (kvp.Value is IEnumerable<object>)
+                {
+                    throw new ArgumentException(
+                        $"Invalid 'parts' format: key '{kvp.Key}' has an array value. " +
+                        $"'parts' must be a flat list of objects or a name-keyed dict — " +
+                        "not a nested {" + kvp.Key + ": [...]} structure.");
+                }
+                var itemDict = kvp.Value.GetDictionary();
+                if (itemDict.Count > 0)
+                {
+                    // Value is an object, add name to it
+                    itemDict["name"] = kvp.Key;
+                    result.Add(ContentPart.Load(itemDict, context));
+                }
+                else
+                {
+                    // Value is a scalar, use it as the primary property
+                    var newDict = new Dictionary<string, object?>
+                    {
+                        ["name"] = kvp.Key,
+                        ["kind"] = kvp.Value
+                    };
+                    result.Add(ContentPart.Load(newDict, context));
+                }
+            }
+        }
+        else if (data is IEnumerable<object> list)
+        {
+            foreach (var item in list)
+            {
+                var itemDict = item.GetDictionary(ContentPart.ShorthandProperty);
+                if (itemDict.Count > 0)
+                {
+                    result.Add(ContentPart.Load(itemDict, context));
+                }
+            }
+        }
+
+        return result;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ToolResult instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["parts"] = SaveParts(obj.Parts, context);
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Save a list of ContentPart to object or array format.
+    /// </summary>
+    public static object SaveParts(IList<ContentPart> items, SaveContext? context)
+    {
+        context ??= new SaveContext();
+
+        // This collection type does not have a 'name' property, only array format is supported
+        return items.Select(item => item.Save(context)).ToList();
+
+    }
+
+
+    /// <summary>
+    /// Convert the ToolResult instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ToolResult instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ToolResult instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolResult instance.</returns>
+    public static ToolResult FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ToolResult instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolResult instance.</returns>
+    public static ToolResult FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+
+    #region Factory Methods
+
+    /// <summary>
+    /// Create a ToolResult with preset field values.
+    /// </summary>
+    public static ToolResult CreateText(string value)
+    {
+        return new ToolResult { Parts = new List<ContentPart> { new TextPart { Value = value } } };
+    }
+
+    #endregion
+}
+
+/// <summary>
+/// Helper contract for <see cref="ToolResult"/>.
+///
+/// Runtime implementations must provide these members on ToolResult (via a
+/// hand-written partial class). The C# compiler enforces conformance
+/// because ToolResult declares : IToolResultHelpers.
+/// </summary>
+public partial interface IToolResultHelpers
+{
+    /// <summary>
+    /// Concatenate all TextPart values joined by newline
+    /// </summary>
+    string Text { get; }
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ToolResultHelpers.cs b/runtime/csharp/Prompty.Core/Model/ToolResultHelpers.cs
new file mode 100644
index 00000000..aa46ebe4
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ToolResultHelpers.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// --- Runtime helpers (manually maintained) ---
+// This file extends the generated ToolResult class with convenience members
+// used by the Prompty pipeline and tool dispatch system.
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+public partial class ToolResult
+{
+    /// <summary>
+    /// Create a ToolResult from a plain text string (wraps in a single TextPart).
+    /// </summary>
+    public static ToolResult FromText(string text) =>
+        new() { Parts = [new TextPart { Value = text }] };
+
+    /// <summary>
+    /// Concatenated text from all TextParts in this result.
+    /// </summary>
+    public string Text => string.Join("", Parts.OfType<TextPart>().Select(p => p.Value));
+
+    /// <summary>
+    /// Implicit conversion from string for backward compatibility.
+    /// Existing code returning strings from tool handlers will continue to work.
+    /// </summary>
+    public static implicit operator ToolResult(string text) => FromText(text);
+}
diff --git a/runtime/csharp/Prompty.Core/Model/ToolResultPayload.cs b/runtime/csharp/Prompty.Core/Model/ToolResultPayload.cs
new file mode 100644
index 00000000..07e378be
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/ToolResultPayload.cs
@@ -0,0 +1,168 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Payload for "tool_result" events — a tool has returned its result.
+/// </summary>
+public partial class ToolResultPayload
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ToolResultPayload"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public ToolResultPayload()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// The name of the tool that produced the result
+    /// </summary>
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The tool's result
+    /// </summary>
+    public ToolResult Result { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a ToolResultPayload instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolResultPayload instance.</returns>
+    public static ToolResultPayload Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new ToolResultPayload();
+
+
+        if (data.TryGetValue("name", out var nameValue) && nameValue is not null)
+        {
+            instance.Name = nameValue?.ToString()!;
+        }
+
+        if (data.TryGetValue("result", out var resultValue) && resultValue is not null)
+        {
+            instance.Result = ToolResult.Load(resultValue.GetDictionary(ToolResult.ShorthandProperty), context);
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the ToolResultPayload instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        result["name"] = obj.Name;
+
+
+        result["result"] = obj.Result?.Save(context);
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the ToolResultPayload instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the ToolResultPayload instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a ToolResultPayload instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolResultPayload instance.</returns>
+    public static ToolResultPayload FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a ToolResultPayload instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded ToolResultPayload instance.</returns>
+    public static ToolResultPayload FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Model/TurnOptions.cs b/runtime/csharp/Prompty.Core/Model/TurnOptions.cs
new file mode 100644
index 00000000..99d25995
--- /dev/null
+++ b/runtime/csharp/Prompty.Core/Model/TurnOptions.cs
@@ -0,0 +1,262 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace Prompty.Core;
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Configuration for the agent loop's turn() function. Controls iteration
+/// 
+/// limits, retry policy, context management, and execution behavior.
+/// 
+/// Runtimes accept these as either a TurnOptions object or individual
+/// 
+/// keyword/named parameters — the TypeSpec model defines the canonical
+/// 
+/// field set.
+/// </summary>
+public partial class TurnOptions
+{
+    /// <summary>
+    /// The shorthand property name for this type, if any.
+    /// </summary>
+    public static string? ShorthandProperty => null;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="TurnOptions"/>.
+    /// </summary>
+#pragma warning disable CS8618
+    public TurnOptions()
+    {
+    }
+#pragma warning restore CS8618
+
+    /// <summary>
+    /// Maximum number of tool-call iterations before the loop terminates
+    /// </summary>
+    public int? MaxIterations { get; set; }
+
+    /// <summary>
+    /// Maximum number of LLM call retries on transient failure within a single iteration
+    /// </summary>
+    public int? MaxLlmRetries { get; set; }
+
+    /// <summary>
+    /// Character budget for the context window. When set, the loop trims older messages to stay within budget before each LLM call. System messages are never dropped.
+    /// </summary>
+    public int? ContextBudget { get; set; }
+
+    /// <summary>
+    /// Whether to execute multiple tool calls concurrently when the LLM returns several in one response
+    /// </summary>
+    public bool? ParallelToolCalls { get; set; }
+
+    /// <summary>
+    /// When true, return the raw LLM response without processor post-processing
+    /// </summary>
+    public bool? Raw { get; set; }
+
+    /// <summary>
+    /// Turn number for trace labeling. Useful when the caller maintains an outer conversation loop.
+    /// </summary>
+    public int? Turn { get; set; }
+
+    /// <summary>
+    /// Context compaction configuration. Controls how messages are summarized when the context window exceeds the budget.
+    /// </summary>
+    public CompactionConfig? Compaction { get; set; }
+
+
+
+    #region Load Methods
+
+    /// <summary>
+    /// Load a TurnOptions instance from a dictionary.
+    /// </summary>
+    /// <param name="data">The dictionary containing the data.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TurnOptions instance.</returns>
+    public static TurnOptions Load(Dictionary<string, object?> data, LoadContext? context = null)
+    {
+        if (context is not null)
+        {
+            data = context.ProcessInput(data);
+        }
+
+
+        // Create new instance
+        var instance = new TurnOptions();
+
+
+        if (data.TryGetValue("maxIterations", out var maxIterationsValue) && maxIterationsValue is not null)
+        {
+            instance.MaxIterations = Convert.ToInt32(maxIterationsValue);
+        }
+
+        if (data.TryGetValue("maxLlmRetries", out var maxLlmRetriesValue) && maxLlmRetriesValue is not null)
+        {
+            instance.MaxLlmRetries = Convert.ToInt32(maxLlmRetriesValue);
+        }
+
+        if (data.TryGetValue("contextBudget", out var contextBudgetValue) && contextBudgetValue is not null)
+        {
+            instance.ContextBudget = Convert.ToInt32(contextBudgetValue);
+        }
+
+        if (data.TryGetValue("parallelToolCalls", out var parallelToolCallsValue) && parallelToolCallsValue is not null)
+        {
+            instance.ParallelToolCalls = Convert.ToBoolean(parallelToolCallsValue);
+        }
+
+        if (data.TryGetValue("raw", out var rawValue) && rawValue is not null)
+        {
+            instance.Raw = Convert.ToBoolean(rawValue);
+        }
+
+        if (data.TryGetValue("turn", out var turnValue) && turnValue is not null)
+        {
+            instance.Turn = Convert.ToInt32(turnValue);
+        }
+
+        if (data.TryGetValue("compaction", out var compactionValue) && compactionValue is not null)
+        {
+            instance.Compaction = CompactionConfig.Load(compactionValue.GetDictionary(CompactionConfig.ShorthandProperty), context);
+        }
+
+        if (context is not null)
+        {
+            instance = context.ProcessOutput(instance);
+        }
+        return instance;
+    }
+
+
+    #endregion
+
+    #region Save Methods
+
+    /// <summary>
+    /// Save the TurnOptions instance to a dictionary.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The dictionary representation of this instance.</returns>
+    public Dictionary<string, object?> Save(SaveContext? context = null)
+    {
+        var obj = this;
+        if (context is not null)
+        {
+            obj = context.ProcessObject(obj);
+        }
+
+
+        var result = new Dictionary<string, object?>();
+
+
+        if (obj.MaxIterations is not null)
+        {
+            result["maxIterations"] = obj.MaxIterations;
+        }
+
+
+        if (obj.MaxLlmRetries is not null)
+        {
+            result["maxLlmRetries"] = obj.MaxLlmRetries;
+        }
+
+
+        if (obj.ContextBudget is not null)
+        {
+            result["contextBudget"] = obj.ContextBudget;
+        }
+
+
+        if (obj.ParallelToolCalls is not null)
+        {
+            result["parallelToolCalls"] = obj.ParallelToolCalls;
+        }
+
+
+        if (obj.Raw is not null)
+        {
+            result["raw"] = obj.Raw;
+        }
+
+
+        if (obj.Turn is not null)
+        {
+            result["turn"] = obj.Turn;
+        }
+
+
+        if (obj.Compaction is not null)
+        {
+            result["compaction"] = obj.Compaction?.Save(context);
+        }
+
+
+        if (context is not null)
+        {
+            result = context.ProcessDict(result);
+        }
+
+        return result;
+    }
+
+
+    /// <summary>
+    /// Convert the TurnOptions instance to a YAML string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The YAML string representation of this instance.</returns>
+    public string ToYaml(SaveContext? context = null)
+    {
+        context ??= new SaveContext();
+        return context.ToYaml(Save(context));
+    }
+
+    /// <summary>
+    /// Convert the TurnOptions instance to a JSON string.
+    /// </summary>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation of this instance.</returns>
+    public string ToJson(SaveContext? context = null, bool indent = true)
+    {
+        context ??= new SaveContext();
+        return context.ToJson(Save(context), indent);
+    }
+
+    /// <summary>
+    /// Load a TurnOptions instance from a JSON string.
+    /// </summary>
+    /// <param name="json">The JSON string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TurnOptions instance.</returns>
+    public static TurnOptions FromJson(string json, LoadContext? context = null)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Dictionary<string, object?> dict;
+        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
+            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
+
+        return Load(dict, context);
+    }
+
+    /// <summary>
+    /// Load a TurnOptions instance from a YAML string.
+    /// </summary>
+    /// <param name="yaml">The YAML string to parse.</param>
+    /// <param name="context">Optional context with pre/post processing callbacks.</param>
+    /// <returns>The loaded TurnOptions instance.</returns>
+    public static TurnOptions FromYaml(string yaml, LoadContext? context = null)
+    {
+        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
+            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
+
+        return Load(dict, context);
+    }
+
+    #endregion
+}
diff --git a/runtime/csharp/Prompty.Core/Pipeline.cs b/runtime/csharp/Prompty.Core/Pipeline.cs
index 174bf065..26e2c358 100644
--- a/runtime/csharp/Prompty.Core/Pipeline.cs
+++ b/runtime/csharp/Prompty.Core/Pipeline.cs
@@ -76,14 +76,14 @@ public static async Task<string> RenderAsync(Prompty agent, Dictionary<string, o
     /// <summary>
     /// Parse rendered text into a list of Messages.
     /// </summary>
-    public static async Task<List<Message>> ParseAsync(Prompty agent, string rendered)
+    public static async Task<List<Message>> ParseAsync(Prompty agent, string rendered, Dictionary<string, object?>? context)
     {
         return await Trace.TraceAsync<List<Message>>("Prompty.Core.Pipeline.ParseAsync", async (emit) =>
         {
             emit("inputs", new Dictionary<string, object?> { ["agent"] = agent.Name });
             var parserKind = agent.Template?.Parser?.Kind ?? "prompty";
             var parser = InvokerRegistry.GetParser(parserKind);
-            return await parser.ParseAsync(agent, rendered);
+            return await parser.ParseAsync(agent, rendered, null);
         });
     }
 
@@ -151,7 +151,7 @@ public static async Task<List<Message>> PrepareAsync(
                 rendered = await RenderAsync(agent, validatedInputs);
             }
 
-            var messages = await parser.ParseAsync(agent, rendered);
+            var messages = await parser.ParseAsync(agent, rendered, parserContext);
             messages = ExpandThreadMarkers(messages, validatedInputs);
             return messages;
         });
@@ -769,7 +769,7 @@ internal static List<Message> ExpandThreadMarkers(
                 {
                     Role = msg.Role,
                     Parts = [new TextPart { Value = before }],
-                    Metadata = new Dictionary<string, object?>(msg.Metadata),
+                    Metadata = msg.Metadata is not null ? new Dictionary<string, object>(msg.Metadata) : null,
                 });
             }
 
@@ -783,7 +783,7 @@ internal static List<Message> ExpandThreadMarkers(
                 {
                     Role = msg.Role,
                     Parts = [new TextPart { Value = after }],
-                    Metadata = new Dictionary<string, object?>(msg.Metadata),
+                    Metadata = msg.Metadata is not null ? new Dictionary<string, object>(msg.Metadata) : null,
                 });
             }
         }
@@ -792,16 +792,6 @@ internal static List<Message> ExpandThreadMarkers(
     }
 }
 
-/// <summary>
-/// Represents a tool call requested by the LLM.
-/// </summary>
-public class ToolCall
-{
-    public string Id { get; set; } = "";
-    public string Name { get; set; } = "";
-    public string Arguments { get; set; } = "";
-}
-
 /// <summary>
 /// Result from a processor indicating the LLM wants to call tools.
 /// Processors return this instead of a plain string when tool_calls are present.
diff --git a/runtime/csharp/Prompty.Core/PromptyChatParser.cs b/runtime/csharp/Prompty.Core/PromptyChatParser.cs
index 32df4234..3be861f4 100644
--- a/runtime/csharp/Prompty.Core/PromptyChatParser.cs
+++ b/runtime/csharp/Prompty.Core/PromptyChatParser.cs
@@ -71,7 +71,7 @@ public partial class PromptyChatParser : IParser, IPreRenderable
     // IParser
     // -----------------------------------------------------------------------
 
-    public Task<List<Message>> ParseAsync(Prompty agent, string rendered)
+    public Task<List<Message>> ParseAsync(Prompty agent, string rendered, Dictionary<string, object?>? context)
     {
         var messages = Parse(rendered);
         return Task.FromResult(messages);
@@ -160,6 +160,7 @@ private Message CreateMessage(string role, List<string> contentLines, Dictionary
 
         if (attrs is not null && attrs.Count > 0)
         {
+            message.Metadata ??= new Dictionary<string, object>();
             foreach (var kvp in attrs)
                 message.Metadata[kvp.Key] = kvp.Value;
         }
diff --git a/runtime/csharp/Prompty.Core/Types.cs b/runtime/csharp/Prompty.Core/Types.cs
index 66d87c04..4b5f38bc 100644
--- a/runtime/csharp/Prompty.Core/Types.cs
+++ b/runtime/csharp/Prompty.Core/Types.cs
@@ -30,101 +30,7 @@ public static class RichKinds
     };
 }
 
-/// <summary>
-/// Base class for content parts within a message.
-/// </summary>
-public abstract class ContentPart
-{
-    public abstract string Kind { get; }
-}
-
-/// <summary>
-/// Plain text content.
-/// </summary>
-public class TextPart : ContentPart
-{
-    public override string Kind => "text";
-    public string Value { get; set; } = "";
-}
-
-/// <summary>
-/// Image content with source URL/base64 and optional detail level.
-/// </summary>
-public class ImagePart : ContentPart
-{
-    public override string Kind => "image";
-    public string Source { get; set; } = "";
-    public string? Detail { get; set; }
-    public string? MediaType { get; set; }
-}
-
-/// <summary>
-/// File content with source URL/path.
-/// </summary>
-public class FilePart : ContentPart
-{
-    public override string Kind => "file";
-    public string Source { get; set; } = "";
-    public string? MediaType { get; set; }
-}
-
-/// <summary>
-/// Audio content with source URL/base64.
-/// </summary>
-public class AudioPart : ContentPart
-{
-    public override string Kind => "audio";
-    public string Source { get; set; } = "";
-    public string? MediaType { get; set; }
-}
-
-/// <summary>
-/// A message in the LLM conversation with role, content parts, and metadata.
-/// </summary>
-public class Message
-{
-    public string Role { get; set; } = Roles.User;
-    public List<ContentPart> Parts { get; set; } = [];
-    public Dictionary<string, object?> Metadata { get; set; } = [];
-
-    /// <summary>
-    /// Concatenated text from all TextParts.
-    /// </summary>
-    public string Text => string.Join("", Parts.OfType<TextPart>().Select(p => p.Value));
-
-    /// <summary>
-    /// Returns the content as a simple string if only text parts exist,
-    /// or as a list of wire-format dictionaries for multimodal content.
-    /// </summary>
-    public object ToTextContent()
-    {
-        if (Parts.All(p => p is TextPart))
-            return Text;
-
-        return Parts.Select<ContentPart, Dictionary<string, object?>>(p => p switch
-        {
-            TextPart t => new() { ["type"] = "text", ["text"] = t.Value },
-            ImagePart i => new()
-            {
-                ["type"] = "image_url",
-                ["image_url"] = new Dictionary<string, object?>
-                {
-                    ["url"] = i.Source,
-                    ["detail"] = i.Detail ?? "auto",
-                },
-            },
-            FilePart f => new() { ["type"] = "file", ["file"] = new Dictionary<string, object?> { ["url"] = f.Source } },
-            AudioPart a => new() { ["type"] = "input_audio", ["input_audio"] = new Dictionary<string, object?> { ["url"] = a.Source } },
-            _ => new() { ["type"] = p.Kind },
-        }).ToList();
-    }
-}
-
 /// <summary>
 /// Placeholder inserted by renderers to mark where thread/rich content should be expanded.
 /// </summary>
-public class ThreadMarker
-{
-    public string Name { get; set; } = "thread";
-    public string Kind { get; set; } = "thread";
-}
+public partial class ThreadMarker { }
diff --git a/runtime/csharp/Prompty.OpenAI/WireFormat.cs b/runtime/csharp/Prompty.OpenAI/WireFormat.cs
index bef94fb1..156442bd 100644
--- a/runtime/csharp/Prompty.OpenAI/WireFormat.cs
+++ b/runtime/csharp/Prompty.OpenAI/WireFormat.cs
@@ -37,13 +37,13 @@ public static ChatMessage MessageToWire(Message msg)
             },
             Roles.Assistant => BuildAssistantMessage(msg),
             Roles.Tool => new ToolChatMessage(
-                msg.Metadata.TryGetValue("tool_call_id", out var id) ? id?.ToString() ?? "" : "",
+                msg.Metadata?.TryGetValue("tool_call_id", out var id) == true ? id?.ToString() ?? "" : "",
                 msg.Text),
             _ => new UserChatMessage(msg.Text),
         };
     }
 
-    private static IEnumerable<ChatMessageContentPart> BuildContentParts(List<ContentPart> parts)
+    private static IEnumerable<ChatMessageContentPart> BuildContentParts(IList<ContentPart> parts)
     {
         foreach (var part in parts)
         {
@@ -71,7 +71,7 @@ private static AssistantChatMessage BuildAssistantMessage(Message msg)
         var assistant = new AssistantChatMessage(msg.Text);
 
         // Attach tool calls from metadata if present
-        if (msg.Metadata.TryGetValue("tool_calls", out var tcObj) && tcObj is List<ToolCall> toolCalls)
+        if (msg.Metadata is not null && msg.Metadata.TryGetValue("tool_calls", out var tcObj) && tcObj is List<ToolCall> toolCalls)
         {
             foreach (var tc in toolCalls)
             {
@@ -128,6 +128,8 @@ private static AssistantChatMessage BuildAssistantMessage(Message msg)
 
     /// <summary>
     /// Build ChatCompletionOptions from agent's ModelOptions.
+    /// Note: ModelOptions.ToWire("openai") is available for raw HTTP providers,
+    /// but this method uses the strongly-typed OpenAI SDK ChatCompletionOptions object.
     /// </summary>
     public static ChatCompletionOptions BuildOptions(Core.Prompty agent)
     {
@@ -251,11 +253,11 @@ public static CreateResponseOptions BuildResponsesOptions(string model, Core.Pro
     public static ResponseItem? MessageToResponsesInput(Message msg)
     {
         // Pass through function call items stored in metadata
-        if (msg.Metadata.TryGetValue("responses_function_call", out var fcObj) && fcObj is ResponseItem fcItem)
+        if (msg.Metadata is not null && msg.Metadata.TryGetValue("responses_function_call", out var fcObj) && fcObj is ResponseItem fcItem)
             return fcItem;
 
         // Tool result → function_call_output
-        if (msg.Role == Roles.Tool && msg.Metadata.TryGetValue("tool_call_id", out var tcId))
+        if (msg.Role == Roles.Tool && msg.Metadata is not null && msg.Metadata.TryGetValue("tool_call_id", out var tcId))
         {
             return ResponseItem.CreateFunctionCallOutputItem(
                 tcId?.ToString() ?? "",
diff --git a/runtime/csharp/Prompty.Providers.Tests/AgentLoopTests.cs b/runtime/csharp/Prompty.Providers.Tests/AgentLoopTests.cs
index 4d3fbb75..aa7026c3 100644
--- a/runtime/csharp/Prompty.Providers.Tests/AgentLoopTests.cs
+++ b/runtime/csharp/Prompty.Providers.Tests/AgentLoopTests.cs
@@ -262,7 +262,7 @@ public Task<string> RenderAsync(Core.Prompty agent, string template, Dictionary<
     /// <summary>Parser that returns a single user message.</summary>
     private class PassthroughParser : IParser
     {
-        public Task<List<Message>> ParseAsync(Core.Prompty agent, string rendered)
+        public Task<List<Message>> ParseAsync(Core.Prompty agent, string rendered, Dictionary<string, object?>? context)
             => Task.FromResult<List<Message>>([new() { Role = Roles.User, Parts = [new TextPart { Value = rendered }] }]);
     }
 
@@ -327,10 +327,10 @@ private static List<Message> DefaultFormatToolMessages(List<ToolCall> toolCalls,
     {
         var messages = new List<Message>
         {
-            new() { Role = Roles.Assistant, Parts = string.IsNullOrEmpty(textContent) ? [] : [new TextPart { Value = textContent }], Metadata = new() { ["tool_calls"] = toolCalls } },
+            new() { Role = Roles.Assistant, Parts = string.IsNullOrEmpty(textContent) ? [] : [new TextPart { Value = textContent }], Metadata = new Dictionary<string, object> { ["tool_calls"] = toolCalls } },
         };
         for (var i = 0; i < toolCalls.Count; i++)
-            messages.Add(new() { Role = Roles.Tool, Parts = [new TextPart { Value = toolResults[i] }], Metadata = new() { ["tool_call_id"] = toolCalls[i].Id, ["name"] = toolCalls[i].Name } });
+            messages.Add(new() { Role = Roles.Tool, Parts = [new TextPart { Value = toolResults[i] }], Metadata = new Dictionary<string, object> { ["tool_call_id"] = toolCalls[i].Id, ["name"] = toolCalls[i].Name } });
         return messages;
     }
 }
diff --git a/runtime/csharp/Prompty.Providers.Tests/SpecVectorAgentTests.cs b/runtime/csharp/Prompty.Providers.Tests/SpecVectorAgentTests.cs
index 92df5b0b..166d704c 100644
--- a/runtime/csharp/Prompty.Providers.Tests/SpecVectorAgentTests.cs
+++ b/runtime/csharp/Prompty.Providers.Tests/SpecVectorAgentTests.cs
@@ -696,7 +696,7 @@ public Task<string> RenderAsync(Core.Prompty agent, string template, Dictionary<
 
     private class PassthroughParser : IParser
     {
-        public Task<List<Message>> ParseAsync(Core.Prompty agent, string rendered)
+        public Task<List<Message>> ParseAsync(Core.Prompty agent, string rendered, Dictionary<string, object?>? context)
         {
             var msgs = new List<Message>
             {
@@ -722,10 +722,10 @@ public List<Message> FormatToolMessages(object rawResponse, List<ToolCall> toolC
         {
             var messages = new List<Message>
             {
-                new() { Role = Roles.Assistant, Parts = [], Metadata = new() { ["tool_calls"] = toolCalls } },
+                new() { Role = Roles.Assistant, Parts = [], Metadata = new Dictionary<string, object> { ["tool_calls"] = toolCalls } },
             };
             for (var i = 0; i < toolCalls.Count; i++)
-                messages.Add(new() { Role = Roles.Tool, Parts = [new TextPart { Value = toolResults[i] }], Metadata = new() { ["tool_call_id"] = toolCalls[i].Id, ["name"] = toolCalls[i].Name } });
+                messages.Add(new() { Role = Roles.Tool, Parts = [new TextPart { Value = toolResults[i] }], Metadata = new Dictionary<string, object> { ["tool_call_id"] = toolCalls[i].Id, ["name"] = toolCalls[i].Name } });
             return messages;
         }
     }
diff --git a/runtime/csharp/Prompty.Providers.Tests/WireFormatTests.cs b/runtime/csharp/Prompty.Providers.Tests/WireFormatTests.cs
index a84f67f2..1d0a0d8e 100644
--- a/runtime/csharp/Prompty.Providers.Tests/WireFormatTests.cs
+++ b/runtime/csharp/Prompty.Providers.Tests/WireFormatTests.cs
@@ -94,7 +94,7 @@ public void MessageToWire_AssistantWithToolCalls_PreservesToolCalls()
         {
             Role = Roles.Assistant,
             Parts = [new TextPart { Value = "" }],
-            Metadata = new()
+            Metadata = new Dictionary<string, object>
             {
                 ["tool_calls"] = new List<ToolCall>
                 {
@@ -116,7 +116,7 @@ public void MessageToWire_ToolMessage_ReturnsToolChatMessage()
         {
             Role = Roles.Tool,
             Parts = [new TextPart { Value = "72°F and sunny" }],
-            Metadata = new() { ["tool_call_id"] = "call_1" },
+            Metadata = new Dictionary<string, object> { ["tool_call_id"] = "call_1" },
         };
 
         var result = WireFormat.MessageToWire(msg);
diff --git a/runtime/go/prompty/go.mod b/runtime/go/prompty/go.mod
new file mode 100644
index 00000000..3a16a34f
--- /dev/null
+++ b/runtime/go/prompty/go.mod
@@ -0,0 +1,5 @@
+module prompty
+
+go 1.25.1
+
+require gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/runtime/go/prompty/go.sum b/runtime/go/prompty/go.sum
new file mode 100644
index 00000000..4bc03378
--- /dev/null
+++ b/runtime/go/prompty/go.sum
@@ -0,0 +1,3 @@
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/runtime/go/prompty/model/anonymous_connection_test.go b/runtime/go/prompty/model/anonymous_connection_test.go
index 26e651ce..554368e4 100644
--- a/runtime/go/prompty/model/anonymous_connection_test.go
+++ b/runtime/go/prompty/model/anonymous_connection_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestAnonymousConnectionLoadJSON tests loading AnonymousConnection from JSON
diff --git a/runtime/go/prompty/model/api_key_connection_test.go b/runtime/go/prompty/model/api_key_connection_test.go
index 673f18b3..31684916 100644
--- a/runtime/go/prompty/model/api_key_connection_test.go
+++ b/runtime/go/prompty/model/api_key_connection_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestApiKeyConnectionLoadJSON tests loading ApiKeyConnection from JSON
diff --git a/runtime/go/prompty/model/array_property_test.go b/runtime/go/prompty/model/array_property_test.go
index 6b1bc62c..8722b36a 100644
--- a/runtime/go/prompty/model/array_property_test.go
+++ b/runtime/go/prompty/model/array_property_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestArrayPropertyLoadJSON tests loading ArrayProperty from JSON
diff --git a/runtime/go/prompty/model/audio_part_test.go b/runtime/go/prompty/model/audio_part_test.go
new file mode 100644
index 00000000..acca1517
--- /dev/null
+++ b/runtime/go/prompty/model/audio_part_test.go
@@ -0,0 +1,154 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestAudioPartLoadJSON tests loading AudioPart from JSON
+func TestAudioPartLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/audio.wav",
+  "mediaType": "audio/wav"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadAudioPart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load AudioPart: %v", err)
+	}
+	if instance.Source != "https://example.com/audio.wav" {
+		t.Errorf(`Expected Source to be "https://example.com/audio.wav", got %v`, instance.Source)
+	}
+	if instance.MediaType == nil || *instance.MediaType != "audio/wav" {
+		t.Errorf(`Expected MediaType to be "audio/wav", got %v`, instance.MediaType)
+	}
+}
+
+// TestAudioPartLoadYAML tests loading AudioPart from YAML
+func TestAudioPartLoadYAML(t *testing.T) {
+	yamlData := `
+source: "https://example.com/audio.wav"
+mediaType: audio/wav
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadAudioPart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load AudioPart: %v", err)
+	}
+	if instance.Source != "https://example.com/audio.wav" {
+		t.Errorf(`Expected Source to be "https://example.com/audio.wav", got %v`, instance.Source)
+	}
+	if instance.MediaType == nil || *instance.MediaType != "audio/wav" {
+		t.Errorf(`Expected MediaType to be "audio/wav", got %v`, instance.MediaType)
+	}
+}
+
+// TestAudioPartRoundtrip tests load -> save -> load produces equivalent data
+func TestAudioPartRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/audio.wav",
+  "mediaType": "audio/wav"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadAudioPart(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load AudioPart: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadAudioPart(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload AudioPart: %v", err)
+	}
+	if reloaded.Source != "https://example.com/audio.wav" {
+		t.Errorf(`Expected Source to be "https://example.com/audio.wav", got %v`, reloaded.Source)
+	}
+	if reloaded.MediaType == nil || *reloaded.MediaType != "audio/wav" {
+		t.Errorf(`Expected MediaType to be "audio/wav", got %v`, reloaded.MediaType)
+	}
+}
+
+// TestAudioPartToJSON tests that ToJSON produces valid JSON
+func TestAudioPartToJSON(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/audio.wav",
+  "mediaType": "audio/wav"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadAudioPart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load AudioPart: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestAudioPartToYAML tests that ToYAML produces valid YAML
+func TestAudioPartToYAML(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/audio.wav",
+  "mediaType": "audio/wav"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadAudioPart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load AudioPart: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/binding_test.go b/runtime/go/prompty/model/binding_test.go
index 0fc94143..7362ea71 100644
--- a/runtime/go/prompty/model/binding_test.go
+++ b/runtime/go/prompty/model/binding_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestBindingLoadJSON tests loading Binding from JSON
diff --git a/runtime/go/prompty/model/compaction_complete_payload.go b/runtime/go/prompty/model/compaction_complete_payload.go
new file mode 100644
index 00000000..722ebeb9
--- /dev/null
+++ b/runtime/go/prompty/model/compaction_complete_payload.go
@@ -0,0 +1,106 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// CompactionCompletePayload represents Payload for "compaction_complete" events — context compaction finished.
+
+type CompactionCompletePayload struct {
+	Removed   int32 `json:"removed" yaml:"removed"`
+	Remaining int32 `json:"remaining" yaml:"remaining"`
+}
+
+// LoadCompactionCompletePayload creates a CompactionCompletePayload from a map[string]interface{}
+func LoadCompactionCompletePayload(data interface{}, ctx *LoadContext) (CompactionCompletePayload, error) {
+	result := CompactionCompletePayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["removed"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.Removed = v
+		}
+		if val, ok := m["remaining"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.Remaining = v
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes CompactionCompletePayload to map[string]interface{}
+func (obj *CompactionCompletePayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["removed"] = obj.Removed
+	result["remaining"] = obj.Remaining
+
+	return result
+}
+
+// ToJSON serializes CompactionCompletePayload to JSON string
+func (obj *CompactionCompletePayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes CompactionCompletePayload to YAML string
+func (obj *CompactionCompletePayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates CompactionCompletePayload from JSON string
+func CompactionCompletePayloadFromJSON(jsonStr string) (CompactionCompletePayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return CompactionCompletePayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadCompactionCompletePayload(data, ctx)
+}
+
+// FromYAML creates CompactionCompletePayload from YAML string
+func CompactionCompletePayloadFromYAML(yamlStr string) (CompactionCompletePayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return CompactionCompletePayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadCompactionCompletePayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/compaction_complete_payload_test.go b/runtime/go/prompty/model/compaction_complete_payload_test.go
new file mode 100644
index 00000000..154b92ea
--- /dev/null
+++ b/runtime/go/prompty/model/compaction_complete_payload_test.go
@@ -0,0 +1,154 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestCompactionCompletePayloadLoadJSON tests loading CompactionCompletePayload from JSON
+func TestCompactionCompletePayloadLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "removed": 5,
+  "remaining": 3
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionCompletePayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionCompletePayload: %v", err)
+	}
+	if instance.Removed != 5 {
+		t.Errorf(`Expected Removed to be 5, got %v`, instance.Removed)
+	}
+	if instance.Remaining != 3 {
+		t.Errorf(`Expected Remaining to be 3, got %v`, instance.Remaining)
+	}
+}
+
+// TestCompactionCompletePayloadLoadYAML tests loading CompactionCompletePayload from YAML
+func TestCompactionCompletePayloadLoadYAML(t *testing.T) {
+	yamlData := `
+removed: 5
+remaining: 3
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionCompletePayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionCompletePayload: %v", err)
+	}
+	if instance.Removed != 5 {
+		t.Errorf(`Expected Removed to be 5, got %v`, instance.Removed)
+	}
+	if instance.Remaining != 3 {
+		t.Errorf(`Expected Remaining to be 3, got %v`, instance.Remaining)
+	}
+}
+
+// TestCompactionCompletePayloadRoundtrip tests load -> save -> load produces equivalent data
+func TestCompactionCompletePayloadRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "removed": 5,
+  "remaining": 3
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionCompletePayload(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionCompletePayload: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadCompactionCompletePayload(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload CompactionCompletePayload: %v", err)
+	}
+	if reloaded.Removed != 5 {
+		t.Errorf(`Expected Removed to be 5, got %v`, reloaded.Removed)
+	}
+	if reloaded.Remaining != 3 {
+		t.Errorf(`Expected Remaining to be 3, got %v`, reloaded.Remaining)
+	}
+}
+
+// TestCompactionCompletePayloadToJSON tests that ToJSON produces valid JSON
+func TestCompactionCompletePayloadToJSON(t *testing.T) {
+	jsonData := `
+{
+  "removed": 5,
+  "remaining": 3
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionCompletePayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionCompletePayload: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestCompactionCompletePayloadToYAML tests that ToYAML produces valid YAML
+func TestCompactionCompletePayloadToYAML(t *testing.T) {
+	jsonData := `
+{
+  "removed": 5,
+  "remaining": 3
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionCompletePayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionCompletePayload: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/compaction_config.go b/runtime/go/prompty/model/compaction_config.go
new file mode 100644
index 00000000..792d7ef3
--- /dev/null
+++ b/runtime/go/prompty/model/compaction_config.go
@@ -0,0 +1,111 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// CompactionConfig represents Configuration for context window compaction. When the message history
+// exceeds the context budget, the compaction strategy is applied to
+// reduce the message list while preserving essential information.
+
+type CompactionConfig struct {
+	Strategy *string                `json:"strategy,omitempty" yaml:"strategy,omitempty"`
+	Budget   *int32                 `json:"budget,omitempty" yaml:"budget,omitempty"`
+	Options  map[string]interface{} `json:"options,omitempty" yaml:"options,omitempty"`
+}
+
+// LoadCompactionConfig creates a CompactionConfig from a map[string]interface{}
+func LoadCompactionConfig(data interface{}, ctx *LoadContext) (CompactionConfig, error) {
+	result := CompactionConfig{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["strategy"]; ok && val != nil {
+			v := val.(string)
+			result.Strategy = &v
+		}
+		if val, ok := m["budget"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.Budget = &v
+		}
+		if val, ok := m["options"]; ok && val != nil {
+			if m, ok := val.(map[string]interface{}); ok {
+				result.Options = m
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes CompactionConfig to map[string]interface{}
+func (obj *CompactionConfig) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	if obj.Strategy != nil {
+		result["strategy"] = *obj.Strategy
+	}
+	if obj.Budget != nil {
+		result["budget"] = *obj.Budget
+	}
+	if obj.Options != nil {
+		result["options"] = obj.Options
+	}
+
+	return result
+}
+
+// ToJSON serializes CompactionConfig to JSON string
+func (obj *CompactionConfig) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes CompactionConfig to YAML string
+func (obj *CompactionConfig) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates CompactionConfig from JSON string
+func CompactionConfigFromJSON(jsonStr string) (CompactionConfig, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return CompactionConfig{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadCompactionConfig(data, ctx)
+}
+
+// FromYAML creates CompactionConfig from YAML string
+func CompactionConfigFromYAML(yamlStr string) (CompactionConfig, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return CompactionConfig{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadCompactionConfig(data, ctx)
+}
diff --git a/runtime/go/prompty/model/compaction_config_test.go b/runtime/go/prompty/model/compaction_config_test.go
new file mode 100644
index 00000000..3116bbb9
--- /dev/null
+++ b/runtime/go/prompty/model/compaction_config_test.go
@@ -0,0 +1,168 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestCompactionConfigLoadJSON tests loading CompactionConfig from JSON
+func TestCompactionConfigLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "strategy": "summarize",
+  "budget": 50000,
+  "options": {
+    "preserveSystemMessages": true
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionConfig(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionConfig: %v", err)
+	}
+	if instance.Strategy == nil || *instance.Strategy != "summarize" {
+		t.Errorf(`Expected Strategy to be "summarize", got %v`, instance.Strategy)
+	}
+	if instance.Budget == nil || *instance.Budget != 50000 {
+		t.Errorf(`Expected Budget to be 50000, got %v`, instance.Budget)
+	}
+}
+
+// TestCompactionConfigLoadYAML tests loading CompactionConfig from YAML
+func TestCompactionConfigLoadYAML(t *testing.T) {
+	yamlData := `
+strategy: summarize
+budget: 50000
+options:
+  preserveSystemMessages: true
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionConfig(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionConfig: %v", err)
+	}
+	if instance.Strategy == nil || *instance.Strategy != "summarize" {
+		t.Errorf(`Expected Strategy to be "summarize", got %v`, instance.Strategy)
+	}
+	if instance.Budget == nil || *instance.Budget != 50000 {
+		t.Errorf(`Expected Budget to be 50000, got %v`, instance.Budget)
+	}
+}
+
+// TestCompactionConfigRoundtrip tests load -> save -> load produces equivalent data
+func TestCompactionConfigRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "strategy": "summarize",
+  "budget": 50000,
+  "options": {
+    "preserveSystemMessages": true
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionConfig(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionConfig: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadCompactionConfig(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload CompactionConfig: %v", err)
+	}
+	if reloaded.Strategy == nil || *reloaded.Strategy != "summarize" {
+		t.Errorf(`Expected Strategy to be "summarize", got %v`, reloaded.Strategy)
+	}
+	if reloaded.Budget == nil || *reloaded.Budget != 50000 {
+		t.Errorf(`Expected Budget to be 50000, got %v`, reloaded.Budget)
+	}
+}
+
+// TestCompactionConfigToJSON tests that ToJSON produces valid JSON
+func TestCompactionConfigToJSON(t *testing.T) {
+	jsonData := `
+{
+  "strategy": "summarize",
+  "budget": 50000,
+  "options": {
+    "preserveSystemMessages": true
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionConfig(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionConfig: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestCompactionConfigToYAML tests that ToYAML produces valid YAML
+func TestCompactionConfigToYAML(t *testing.T) {
+	jsonData := `
+{
+  "strategy": "summarize",
+  "budget": 50000,
+  "options": {
+    "preserveSystemMessages": true
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionConfig(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionConfig: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/compaction_failed_payload.go b/runtime/go/prompty/model/compaction_failed_payload.go
new file mode 100644
index 00000000..4e79f2c3
--- /dev/null
+++ b/runtime/go/prompty/model/compaction_failed_payload.go
@@ -0,0 +1,79 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// CompactionFailedPayload represents Payload for "compaction_failed" events — compaction could not be completed.
+
+type CompactionFailedPayload struct {
+	Message string `json:"message" yaml:"message"`
+}
+
+// LoadCompactionFailedPayload creates a CompactionFailedPayload from a map[string]interface{}
+func LoadCompactionFailedPayload(data interface{}, ctx *LoadContext) (CompactionFailedPayload, error) {
+	result := CompactionFailedPayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["message"]; ok && val != nil {
+			result.Message = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes CompactionFailedPayload to map[string]interface{}
+func (obj *CompactionFailedPayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["message"] = obj.Message
+
+	return result
+}
+
+// ToJSON serializes CompactionFailedPayload to JSON string
+func (obj *CompactionFailedPayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes CompactionFailedPayload to YAML string
+func (obj *CompactionFailedPayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates CompactionFailedPayload from JSON string
+func CompactionFailedPayloadFromJSON(jsonStr string) (CompactionFailedPayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return CompactionFailedPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadCompactionFailedPayload(data, ctx)
+}
+
+// FromYAML creates CompactionFailedPayload from YAML string
+func CompactionFailedPayloadFromYAML(yamlStr string) (CompactionFailedPayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return CompactionFailedPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadCompactionFailedPayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/compaction_failed_payload_test.go b/runtime/go/prompty/model/compaction_failed_payload_test.go
new file mode 100644
index 00000000..75330125
--- /dev/null
+++ b/runtime/go/prompty/model/compaction_failed_payload_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestCompactionFailedPayloadLoadJSON tests loading CompactionFailedPayload from JSON
+func TestCompactionFailedPayloadLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "message": "Summarization prompt exceeded context window"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionFailedPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionFailedPayload: %v", err)
+	}
+	if instance.Message != "Summarization prompt exceeded context window" {
+		t.Errorf(`Expected Message to be "Summarization prompt exceeded context window", got %v`, instance.Message)
+	}
+}
+
+// TestCompactionFailedPayloadLoadYAML tests loading CompactionFailedPayload from YAML
+func TestCompactionFailedPayloadLoadYAML(t *testing.T) {
+	yamlData := `
+message: Summarization prompt exceeded context window
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionFailedPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionFailedPayload: %v", err)
+	}
+	if instance.Message != "Summarization prompt exceeded context window" {
+		t.Errorf(`Expected Message to be "Summarization prompt exceeded context window", got %v`, instance.Message)
+	}
+}
+
+// TestCompactionFailedPayloadRoundtrip tests load -> save -> load produces equivalent data
+func TestCompactionFailedPayloadRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "message": "Summarization prompt exceeded context window"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionFailedPayload(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionFailedPayload: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadCompactionFailedPayload(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload CompactionFailedPayload: %v", err)
+	}
+	if reloaded.Message != "Summarization prompt exceeded context window" {
+		t.Errorf(`Expected Message to be "Summarization prompt exceeded context window", got %v`, reloaded.Message)
+	}
+}
+
+// TestCompactionFailedPayloadToJSON tests that ToJSON produces valid JSON
+func TestCompactionFailedPayloadToJSON(t *testing.T) {
+	jsonData := `
+{
+  "message": "Summarization prompt exceeded context window"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionFailedPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionFailedPayload: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestCompactionFailedPayloadToYAML tests that ToYAML produces valid YAML
+func TestCompactionFailedPayloadToYAML(t *testing.T) {
+	jsonData := `
+{
+  "message": "Summarization prompt exceeded context window"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadCompactionFailedPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load CompactionFailedPayload: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/connection.go b/runtime/go/prompty/model/connection.go
index 3a585211..338c2558 100644
--- a/runtime/go/prompty/model/connection.go
+++ b/runtime/go/prompty/model/connection.go
@@ -35,10 +35,10 @@ func LoadConnection(data interface{}, ctx *LoadContext) (interface{}, error) {
 				return LoadApiKeyConnection(data, ctx)
 			case "anonymous":
 				return LoadAnonymousConnection(data, ctx)
-			case "foundry":
-				return LoadFoundryConnection(data, ctx)
 			case "oauth":
 				return LoadOAuthConnection(data, ctx)
+			case "foundry":
+				return LoadFoundryConnection(data, ctx)
 			}
 		}
 	}
@@ -435,20 +435,22 @@ func AnonymousConnectionFromYAML(yamlStr string) (AnonymousConnection, error) {
 	return LoadAnonymousConnection(data, ctx)
 }
 
-// FoundryConnection represents Connection configuration for Microsoft Foundry projects.
-// Provides project-scoped access to models, tools, and services
-// via Entra ID (DefaultAzureCredential) authentication.
+// OAuthConnection represents Connection configuration using OAuth 2.0 client credentials.
+// Useful for tools and services that require OAuth authentication,
+// such as MCP servers, OpenAPI endpoints, or other REST APIs.
 
-type FoundryConnection struct {
-	Kind           string  `json:"kind" yaml:"kind"`
-	Endpoint       string  `json:"endpoint" yaml:"endpoint"`
-	Name           *string `json:"name,omitempty" yaml:"name,omitempty"`
-	ConnectionType *string `json:"connectionType,omitempty" yaml:"connectionType,omitempty"`
+type OAuthConnection struct {
+	Kind         string   `json:"kind" yaml:"kind"`
+	Endpoint     string   `json:"endpoint" yaml:"endpoint"`
+	ClientId     string   `json:"clientId" yaml:"clientId"`
+	ClientSecret string   `json:"clientSecret" yaml:"clientSecret"`
+	TokenUrl     string   `json:"tokenUrl" yaml:"tokenUrl"`
+	Scopes       []string `json:"scopes,omitempty" yaml:"scopes,omitempty"`
 }
 
-// LoadFoundryConnection creates a FoundryConnection from a map[string]interface{}
-func LoadFoundryConnection(data interface{}, ctx *LoadContext) (FoundryConnection, error) {
-	result := FoundryConnection{}
+// LoadOAuthConnection creates a OAuthConnection from a map[string]interface{}
+func LoadOAuthConnection(data interface{}, ctx *LoadContext) (OAuthConnection, error) {
+	result := OAuthConnection{}
 
 	// Load from map
 	if m, ok := data.(map[string]interface{}); ok {
@@ -458,36 +460,43 @@ func LoadFoundryConnection(data interface{}, ctx *LoadContext) (FoundryConnectio
 		if val, ok := m["endpoint"]; ok && val != nil {
 			result.Endpoint = val.(string)
 		}
-		if val, ok := m["name"]; ok && val != nil {
-			v := val.(string)
-			result.Name = &v
+		if val, ok := m["clientId"]; ok && val != nil {
+			result.ClientId = val.(string)
 		}
-		if val, ok := m["connectionType"]; ok && val != nil {
-			v := val.(string)
-			result.ConnectionType = &v
+		if val, ok := m["clientSecret"]; ok && val != nil {
+			result.ClientSecret = val.(string)
+		}
+		if val, ok := m["tokenUrl"]; ok && val != nil {
+			result.TokenUrl = val.(string)
+		}
+		if val, ok := m["scopes"]; ok && val != nil {
+			if arr, ok := val.([]interface{}); ok {
+				result.Scopes = make([]string, len(arr))
+				for i, v := range arr {
+					result.Scopes[i] = v.(string)
+				}
+			}
 		}
 	}
 
 	return result, nil
 }
 
-// Save serializes FoundryConnection to map[string]interface{}
-func (obj *FoundryConnection) Save(ctx *SaveContext) map[string]interface{} {
+// Save serializes OAuthConnection to map[string]interface{}
+func (obj *OAuthConnection) Save(ctx *SaveContext) map[string]interface{} {
 	result := make(map[string]interface{})
 	result["kind"] = obj.Kind
 	result["endpoint"] = obj.Endpoint
-	if obj.Name != nil {
-		result["name"] = *obj.Name
-	}
-	if obj.ConnectionType != nil {
-		result["connectionType"] = *obj.ConnectionType
-	}
+	result["clientId"] = obj.ClientId
+	result["clientSecret"] = obj.ClientSecret
+	result["tokenUrl"] = obj.TokenUrl
+	result["scopes"] = obj.Scopes
 
 	return result
 }
 
-// ToJSON serializes FoundryConnection to JSON string
-func (obj *FoundryConnection) ToJSON() (string, error) {
+// ToJSON serializes OAuthConnection to JSON string
+func (obj *OAuthConnection) ToJSON() (string, error) {
 	ctx := NewSaveContext()
 	data := obj.Save(ctx)
 	bytes, err := json.Marshal(data)
@@ -497,8 +506,8 @@ func (obj *FoundryConnection) ToJSON() (string, error) {
 	return string(bytes), nil
 }
 
-// ToYAML serializes FoundryConnection to YAML string
-func (obj *FoundryConnection) ToYAML() (string, error) {
+// ToYAML serializes OAuthConnection to YAML string
+func (obj *OAuthConnection) ToYAML() (string, error) {
 	ctx := NewSaveContext()
 	data := obj.Save(ctx)
 	bytes, err := yaml.Marshal(data)
@@ -508,42 +517,40 @@ func (obj *FoundryConnection) ToYAML() (string, error) {
 	return string(bytes), nil
 }
 
-// FromJSON creates FoundryConnection from JSON string
-func FoundryConnectionFromJSON(jsonStr string) (FoundryConnection, error) {
+// FromJSON creates OAuthConnection from JSON string
+func OAuthConnectionFromJSON(jsonStr string) (OAuthConnection, error) {
 	var data map[string]interface{}
 	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
-		return FoundryConnection{}, err
+		return OAuthConnection{}, err
 	}
 	ctx := NewLoadContext()
-	return LoadFoundryConnection(data, ctx)
+	return LoadOAuthConnection(data, ctx)
 }
 
-// FromYAML creates FoundryConnection from YAML string
-func FoundryConnectionFromYAML(yamlStr string) (FoundryConnection, error) {
+// FromYAML creates OAuthConnection from YAML string
+func OAuthConnectionFromYAML(yamlStr string) (OAuthConnection, error) {
 	var data map[string]interface{}
 	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
-		return FoundryConnection{}, err
+		return OAuthConnection{}, err
 	}
 	ctx := NewLoadContext()
-	return LoadFoundryConnection(data, ctx)
+	return LoadOAuthConnection(data, ctx)
 }
 
-// OAuthConnection represents Connection configuration using OAuth 2.0 client credentials.
-// Useful for tools and services that require OAuth authentication,
-// such as MCP servers, OpenAPI endpoints, or other REST APIs.
+// FoundryConnection represents Connection configuration for Microsoft Foundry projects.
+// Provides project-scoped access to models, tools, and services
+// via Entra ID (DefaultAzureCredential) authentication.
 
-type OAuthConnection struct {
-	Kind         string   `json:"kind" yaml:"kind"`
-	Endpoint     string   `json:"endpoint" yaml:"endpoint"`
-	ClientId     string   `json:"clientId" yaml:"clientId"`
-	ClientSecret string   `json:"clientSecret" yaml:"clientSecret"`
-	TokenUrl     string   `json:"tokenUrl" yaml:"tokenUrl"`
-	Scopes       []string `json:"scopes,omitempty" yaml:"scopes,omitempty"`
+type FoundryConnection struct {
+	Kind           string  `json:"kind" yaml:"kind"`
+	Endpoint       string  `json:"endpoint" yaml:"endpoint"`
+	Name           *string `json:"name,omitempty" yaml:"name,omitempty"`
+	ConnectionType *string `json:"connectionType,omitempty" yaml:"connectionType,omitempty"`
 }
 
-// LoadOAuthConnection creates a OAuthConnection from a map[string]interface{}
-func LoadOAuthConnection(data interface{}, ctx *LoadContext) (OAuthConnection, error) {
-	result := OAuthConnection{}
+// LoadFoundryConnection creates a FoundryConnection from a map[string]interface{}
+func LoadFoundryConnection(data interface{}, ctx *LoadContext) (FoundryConnection, error) {
+	result := FoundryConnection{}
 
 	// Load from map
 	if m, ok := data.(map[string]interface{}); ok {
@@ -553,43 +560,36 @@ func LoadOAuthConnection(data interface{}, ctx *LoadContext) (OAuthConnection, e
 		if val, ok := m["endpoint"]; ok && val != nil {
 			result.Endpoint = val.(string)
 		}
-		if val, ok := m["clientId"]; ok && val != nil {
-			result.ClientId = val.(string)
-		}
-		if val, ok := m["clientSecret"]; ok && val != nil {
-			result.ClientSecret = val.(string)
-		}
-		if val, ok := m["tokenUrl"]; ok && val != nil {
-			result.TokenUrl = val.(string)
+		if val, ok := m["name"]; ok && val != nil {
+			v := val.(string)
+			result.Name = &v
 		}
-		if val, ok := m["scopes"]; ok && val != nil {
-			if arr, ok := val.([]interface{}); ok {
-				result.Scopes = make([]string, len(arr))
-				for i, v := range arr {
-					result.Scopes[i] = v.(string)
-				}
-			}
+		if val, ok := m["connectionType"]; ok && val != nil {
+			v := val.(string)
+			result.ConnectionType = &v
 		}
 	}
 
 	return result, nil
 }
 
-// Save serializes OAuthConnection to map[string]interface{}
-func (obj *OAuthConnection) Save(ctx *SaveContext) map[string]interface{} {
+// Save serializes FoundryConnection to map[string]interface{}
+func (obj *FoundryConnection) Save(ctx *SaveContext) map[string]interface{} {
 	result := make(map[string]interface{})
 	result["kind"] = obj.Kind
 	result["endpoint"] = obj.Endpoint
-	result["clientId"] = obj.ClientId
-	result["clientSecret"] = obj.ClientSecret
-	result["tokenUrl"] = obj.TokenUrl
-	result["scopes"] = obj.Scopes
+	if obj.Name != nil {
+		result["name"] = *obj.Name
+	}
+	if obj.ConnectionType != nil {
+		result["connectionType"] = *obj.ConnectionType
+	}
 
 	return result
 }
 
-// ToJSON serializes OAuthConnection to JSON string
-func (obj *OAuthConnection) ToJSON() (string, error) {
+// ToJSON serializes FoundryConnection to JSON string
+func (obj *FoundryConnection) ToJSON() (string, error) {
 	ctx := NewSaveContext()
 	data := obj.Save(ctx)
 	bytes, err := json.Marshal(data)
@@ -599,8 +599,8 @@ func (obj *OAuthConnection) ToJSON() (string, error) {
 	return string(bytes), nil
 }
 
-// ToYAML serializes OAuthConnection to YAML string
-func (obj *OAuthConnection) ToYAML() (string, error) {
+// ToYAML serializes FoundryConnection to YAML string
+func (obj *FoundryConnection) ToYAML() (string, error) {
 	ctx := NewSaveContext()
 	data := obj.Save(ctx)
 	bytes, err := yaml.Marshal(data)
@@ -610,22 +610,22 @@ func (obj *OAuthConnection) ToYAML() (string, error) {
 	return string(bytes), nil
 }
 
-// FromJSON creates OAuthConnection from JSON string
-func OAuthConnectionFromJSON(jsonStr string) (OAuthConnection, error) {
+// FromJSON creates FoundryConnection from JSON string
+func FoundryConnectionFromJSON(jsonStr string) (FoundryConnection, error) {
 	var data map[string]interface{}
 	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
-		return OAuthConnection{}, err
+		return FoundryConnection{}, err
 	}
 	ctx := NewLoadContext()
-	return LoadOAuthConnection(data, ctx)
+	return LoadFoundryConnection(data, ctx)
 }
 
-// FromYAML creates OAuthConnection from YAML string
-func OAuthConnectionFromYAML(yamlStr string) (OAuthConnection, error) {
+// FromYAML creates FoundryConnection from YAML string
+func FoundryConnectionFromYAML(yamlStr string) (FoundryConnection, error) {
 	var data map[string]interface{}
 	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
-		return OAuthConnection{}, err
+		return FoundryConnection{}, err
 	}
 	ctx := NewLoadContext()
-	return LoadOAuthConnection(data, ctx)
+	return LoadFoundryConnection(data, ctx)
 }
diff --git a/runtime/go/prompty/model/connection_test.go b/runtime/go/prompty/model/connection_test.go
index d37de4bd..742c9bc2 100644
--- a/runtime/go/prompty/model/connection_test.go
+++ b/runtime/go/prompty/model/connection_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestConnectionLoadJSON tests loading Connection from JSON
diff --git a/runtime/go/prompty/model/content_part.go b/runtime/go/prompty/model/content_part.go
new file mode 100644
index 00000000..45d65e3f
--- /dev/null
+++ b/runtime/go/prompty/model/content_part.go
@@ -0,0 +1,430 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ContentPart represents A part of a message's content. Content parts are discriminated on the `kind`
+// field and represent the different modalities that can appear in a message.
+
+type ContentPart struct {
+	Kind string `json:"kind" yaml:"kind"`
+}
+
+// LoadContentPart creates a ContentPart from a map[string]interface{}
+// Returns interface{} because this is a polymorphic base type that can resolve to different child types
+func LoadContentPart(data interface{}, ctx *LoadContext) (interface{}, error) {
+	result := ContentPart{}
+
+	// Handle polymorphic types based on discriminator
+	if m, ok := data.(map[string]interface{}); ok {
+		if discriminator, ok := m["kind"]; ok {
+			switch discriminator {
+			case "text":
+				return LoadTextPart(data, ctx)
+			case "image":
+				return LoadImagePart(data, ctx)
+			case "file":
+				return LoadFilePart(data, ctx)
+			case "audio":
+				return LoadAudioPart(data, ctx)
+			}
+		}
+	}
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ContentPart to map[string]interface{}
+func (obj *ContentPart) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+
+	return result
+}
+
+// ToJSON serializes ContentPart to JSON string
+func (obj *ContentPart) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ContentPart to YAML string
+func (obj *ContentPart) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ContentPart from JSON string
+// Returns interface{} because this is a polymorphic base type that can resolve to different child types
+func ContentPartFromJSON(jsonStr string) (interface{}, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return nil, err
+	}
+	ctx := NewLoadContext()
+	return LoadContentPart(data, ctx)
+}
+
+// FromYAML creates ContentPart from YAML string
+// Returns interface{} because this is a polymorphic base type that can resolve to different child types
+func ContentPartFromYAML(yamlStr string) (interface{}, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return nil, err
+	}
+	ctx := NewLoadContext()
+	return LoadContentPart(data, ctx)
+}
+
+// TextPart represents A text content part.
+
+type TextPart struct {
+	Kind  string `json:"kind" yaml:"kind"`
+	Value string `json:"value" yaml:"value"`
+}
+
+// LoadTextPart creates a TextPart from a map[string]interface{}
+func LoadTextPart(data interface{}, ctx *LoadContext) (TextPart, error) {
+	result := TextPart{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+		if val, ok := m["value"]; ok && val != nil {
+			result.Value = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes TextPart to map[string]interface{}
+func (obj *TextPart) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+	result["value"] = obj.Value
+
+	return result
+}
+
+// ToJSON serializes TextPart to JSON string
+func (obj *TextPart) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes TextPart to YAML string
+func (obj *TextPart) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates TextPart from JSON string
+func TextPartFromJSON(jsonStr string) (TextPart, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return TextPart{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTextPart(data, ctx)
+}
+
+// FromYAML creates TextPart from YAML string
+func TextPartFromYAML(yamlStr string) (TextPart, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return TextPart{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTextPart(data, ctx)
+}
+
+// ImagePart represents An image content part. The source may be a URL or base64-encoded data.
+
+type ImagePart struct {
+	Kind      string  `json:"kind" yaml:"kind"`
+	Source    string  `json:"source" yaml:"source"`
+	Detail    *string `json:"detail,omitempty" yaml:"detail,omitempty"`
+	MediaType *string `json:"mediaType,omitempty" yaml:"mediaType,omitempty"`
+}
+
+// LoadImagePart creates a ImagePart from a map[string]interface{}
+func LoadImagePart(data interface{}, ctx *LoadContext) (ImagePart, error) {
+	result := ImagePart{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+		if val, ok := m["source"]; ok && val != nil {
+			result.Source = val.(string)
+		}
+		if val, ok := m["detail"]; ok && val != nil {
+			v := val.(string)
+			result.Detail = &v
+		}
+		if val, ok := m["mediaType"]; ok && val != nil {
+			v := val.(string)
+			result.MediaType = &v
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ImagePart to map[string]interface{}
+func (obj *ImagePart) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+	result["source"] = obj.Source
+	if obj.Detail != nil {
+		result["detail"] = *obj.Detail
+	}
+	if obj.MediaType != nil {
+		result["mediaType"] = *obj.MediaType
+	}
+
+	return result
+}
+
+// ToJSON serializes ImagePart to JSON string
+func (obj *ImagePart) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ImagePart to YAML string
+func (obj *ImagePart) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ImagePart from JSON string
+func ImagePartFromJSON(jsonStr string) (ImagePart, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ImagePart{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadImagePart(data, ctx)
+}
+
+// FromYAML creates ImagePart from YAML string
+func ImagePartFromYAML(yamlStr string) (ImagePart, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ImagePart{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadImagePart(data, ctx)
+}
+
+// FilePart represents A file content part. The source may be a URL or base64-encoded data.
+
+type FilePart struct {
+	Kind      string  `json:"kind" yaml:"kind"`
+	Source    string  `json:"source" yaml:"source"`
+	MediaType *string `json:"mediaType,omitempty" yaml:"mediaType,omitempty"`
+}
+
+// LoadFilePart creates a FilePart from a map[string]interface{}
+func LoadFilePart(data interface{}, ctx *LoadContext) (FilePart, error) {
+	result := FilePart{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+		if val, ok := m["source"]; ok && val != nil {
+			result.Source = val.(string)
+		}
+		if val, ok := m["mediaType"]; ok && val != nil {
+			v := val.(string)
+			result.MediaType = &v
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes FilePart to map[string]interface{}
+func (obj *FilePart) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+	result["source"] = obj.Source
+	if obj.MediaType != nil {
+		result["mediaType"] = *obj.MediaType
+	}
+
+	return result
+}
+
+// ToJSON serializes FilePart to JSON string
+func (obj *FilePart) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes FilePart to YAML string
+func (obj *FilePart) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates FilePart from JSON string
+func FilePartFromJSON(jsonStr string) (FilePart, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return FilePart{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadFilePart(data, ctx)
+}
+
+// FromYAML creates FilePart from YAML string
+func FilePartFromYAML(yamlStr string) (FilePart, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return FilePart{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadFilePart(data, ctx)
+}
+
+// AudioPart represents An audio content part. The source may be a URL or base64-encoded data.
+
+type AudioPart struct {
+	Kind      string  `json:"kind" yaml:"kind"`
+	Source    string  `json:"source" yaml:"source"`
+	MediaType *string `json:"mediaType,omitempty" yaml:"mediaType,omitempty"`
+}
+
+// LoadAudioPart creates a AudioPart from a map[string]interface{}
+func LoadAudioPart(data interface{}, ctx *LoadContext) (AudioPart, error) {
+	result := AudioPart{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+		if val, ok := m["source"]; ok && val != nil {
+			result.Source = val.(string)
+		}
+		if val, ok := m["mediaType"]; ok && val != nil {
+			v := val.(string)
+			result.MediaType = &v
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes AudioPart to map[string]interface{}
+func (obj *AudioPart) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+	result["source"] = obj.Source
+	if obj.MediaType != nil {
+		result["mediaType"] = *obj.MediaType
+	}
+
+	return result
+}
+
+// ToJSON serializes AudioPart to JSON string
+func (obj *AudioPart) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes AudioPart to YAML string
+func (obj *AudioPart) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates AudioPart from JSON string
+func AudioPartFromJSON(jsonStr string) (AudioPart, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return AudioPart{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadAudioPart(data, ctx)
+}
+
+// FromYAML creates AudioPart from YAML string
+func AudioPartFromYAML(yamlStr string) (AudioPart, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return AudioPart{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadAudioPart(data, ctx)
+}
diff --git a/runtime/go/prompty/model/content_part_test.go b/runtime/go/prompty/model/content_part_test.go
new file mode 100644
index 00000000..8e719bf5
--- /dev/null
+++ b/runtime/go/prompty/model/content_part_test.go
@@ -0,0 +1,3 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
diff --git a/runtime/go/prompty/model/context.go b/runtime/go/prompty/model/context.go
index 8152d3b7..9d70e8b5 100644
--- a/runtime/go/prompty/model/context.go
+++ b/runtime/go/prompty/model/context.go
@@ -24,3 +24,9 @@ type SaveContext struct {
 func NewSaveContext() *SaveContext {
 	return &SaveContext{}
 }
+
+// ptrOf returns a pointer to the given value. Used by factory functions
+// to set optional (pointer) fields in struct literals.
+func ptrOf[T any](v T) *T {
+	return &v
+}
diff --git a/runtime/go/prompty/model/custom_tool_test.go b/runtime/go/prompty/model/custom_tool_test.go
index 99f98f47..04148337 100644
--- a/runtime/go/prompty/model/custom_tool_test.go
+++ b/runtime/go/prompty/model/custom_tool_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestCustomToolLoadJSON tests loading CustomTool from JSON
diff --git a/runtime/go/prompty/model/done_event_payload.go b/runtime/go/prompty/model/done_event_payload.go
new file mode 100644
index 00000000..89daec80
--- /dev/null
+++ b/runtime/go/prompty/model/done_event_payload.go
@@ -0,0 +1,98 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// DoneEventPayload represents Payload for "done" events — the agent loop completed successfully.
+
+type DoneEventPayload struct {
+	Response string    `json:"response" yaml:"response"`
+	Messages []Message `json:"messages" yaml:"messages"`
+}
+
+// LoadDoneEventPayload creates a DoneEventPayload from a map[string]interface{}
+func LoadDoneEventPayload(data interface{}, ctx *LoadContext) (DoneEventPayload, error) {
+	result := DoneEventPayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["response"]; ok && val != nil {
+			result.Response = val.(string)
+		}
+		if val, ok := m["messages"]; ok && val != nil {
+			if arr, ok := val.([]interface{}); ok {
+				result.Messages = make([]Message, len(arr))
+				for i, v := range arr {
+					if item, ok := v.(map[string]interface{}); ok {
+						loaded, _ := LoadMessage(item, ctx)
+						result.Messages[i] = loaded
+					}
+				}
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes DoneEventPayload to map[string]interface{}
+func (obj *DoneEventPayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["response"] = obj.Response
+	if obj.Messages != nil {
+		arr := make([]interface{}, len(obj.Messages))
+		for i, item := range obj.Messages {
+			arr[i] = item.Save(ctx)
+		}
+		result["messages"] = arr
+	}
+
+	return result
+}
+
+// ToJSON serializes DoneEventPayload to JSON string
+func (obj *DoneEventPayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes DoneEventPayload to YAML string
+func (obj *DoneEventPayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates DoneEventPayload from JSON string
+func DoneEventPayloadFromJSON(jsonStr string) (DoneEventPayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return DoneEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadDoneEventPayload(data, ctx)
+}
+
+// FromYAML creates DoneEventPayload from YAML string
+func DoneEventPayloadFromYAML(yamlStr string) (DoneEventPayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return DoneEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadDoneEventPayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/done_event_payload_test.go b/runtime/go/prompty/model/done_event_payload_test.go
new file mode 100644
index 00000000..f621b143
--- /dev/null
+++ b/runtime/go/prompty/model/done_event_payload_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestDoneEventPayloadLoadJSON tests loading DoneEventPayload from JSON
+func TestDoneEventPayloadLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "response": "The weather in Paris is 72°F and sunny."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadDoneEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load DoneEventPayload: %v", err)
+	}
+	if instance.Response != "The weather in Paris is 72°F and sunny." {
+		t.Errorf(`Expected Response to be "The weather in Paris is 72°F and sunny.", got %v`, instance.Response)
+	}
+}
+
+// TestDoneEventPayloadLoadYAML tests loading DoneEventPayload from YAML
+func TestDoneEventPayloadLoadYAML(t *testing.T) {
+	yamlData := `
+response: The weather in Paris is 72°F and sunny.
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadDoneEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load DoneEventPayload: %v", err)
+	}
+	if instance.Response != "The weather in Paris is 72°F and sunny." {
+		t.Errorf(`Expected Response to be "The weather in Paris is 72°F and sunny.", got %v`, instance.Response)
+	}
+}
+
+// TestDoneEventPayloadRoundtrip tests load -> save -> load produces equivalent data
+func TestDoneEventPayloadRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "response": "The weather in Paris is 72°F and sunny."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadDoneEventPayload(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load DoneEventPayload: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadDoneEventPayload(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload DoneEventPayload: %v", err)
+	}
+	if reloaded.Response != "The weather in Paris is 72°F and sunny." {
+		t.Errorf(`Expected Response to be "The weather in Paris is 72°F and sunny.", got %v`, reloaded.Response)
+	}
+}
+
+// TestDoneEventPayloadToJSON tests that ToJSON produces valid JSON
+func TestDoneEventPayloadToJSON(t *testing.T) {
+	jsonData := `
+{
+  "response": "The weather in Paris is 72°F and sunny."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadDoneEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load DoneEventPayload: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestDoneEventPayloadToYAML tests that ToYAML produces valid YAML
+func TestDoneEventPayloadToYAML(t *testing.T) {
+	jsonData := `
+{
+  "response": "The weather in Paris is 72°F and sunny."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadDoneEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load DoneEventPayload: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/error_chunk_test.go b/runtime/go/prompty/model/error_chunk_test.go
new file mode 100644
index 00000000..2ed29bc4
--- /dev/null
+++ b/runtime/go/prompty/model/error_chunk_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestErrorChunkLoadJSON tests loading ErrorChunk from JSON
+func TestErrorChunkLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "message": "Rate limit exceeded"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorChunk: %v", err)
+	}
+	if instance.Message != "Rate limit exceeded" {
+		t.Errorf(`Expected Message to be "Rate limit exceeded", got %v`, instance.Message)
+	}
+}
+
+// TestErrorChunkLoadYAML tests loading ErrorChunk from YAML
+func TestErrorChunkLoadYAML(t *testing.T) {
+	yamlData := `
+message: Rate limit exceeded
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorChunk: %v", err)
+	}
+	if instance.Message != "Rate limit exceeded" {
+		t.Errorf(`Expected Message to be "Rate limit exceeded", got %v`, instance.Message)
+	}
+}
+
+// TestErrorChunkRoundtrip tests load -> save -> load produces equivalent data
+func TestErrorChunkRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "message": "Rate limit exceeded"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorChunk(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorChunk: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadErrorChunk(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ErrorChunk: %v", err)
+	}
+	if reloaded.Message != "Rate limit exceeded" {
+		t.Errorf(`Expected Message to be "Rate limit exceeded", got %v`, reloaded.Message)
+	}
+}
+
+// TestErrorChunkToJSON tests that ToJSON produces valid JSON
+func TestErrorChunkToJSON(t *testing.T) {
+	jsonData := `
+{
+  "message": "Rate limit exceeded"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorChunk: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestErrorChunkToYAML tests that ToYAML produces valid YAML
+func TestErrorChunkToYAML(t *testing.T) {
+	jsonData := `
+{
+  "message": "Rate limit exceeded"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorChunk: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/error_event_payload.go b/runtime/go/prompty/model/error_event_payload.go
new file mode 100644
index 00000000..40a7b257
--- /dev/null
+++ b/runtime/go/prompty/model/error_event_payload.go
@@ -0,0 +1,79 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ErrorEventPayload represents Payload for "error" events — an error occurred during the loop.
+
+type ErrorEventPayload struct {
+	Message string `json:"message" yaml:"message"`
+}
+
+// LoadErrorEventPayload creates a ErrorEventPayload from a map[string]interface{}
+func LoadErrorEventPayload(data interface{}, ctx *LoadContext) (ErrorEventPayload, error) {
+	result := ErrorEventPayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["message"]; ok && val != nil {
+			result.Message = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ErrorEventPayload to map[string]interface{}
+func (obj *ErrorEventPayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["message"] = obj.Message
+
+	return result
+}
+
+// ToJSON serializes ErrorEventPayload to JSON string
+func (obj *ErrorEventPayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ErrorEventPayload to YAML string
+func (obj *ErrorEventPayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ErrorEventPayload from JSON string
+func ErrorEventPayloadFromJSON(jsonStr string) (ErrorEventPayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ErrorEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadErrorEventPayload(data, ctx)
+}
+
+// FromYAML creates ErrorEventPayload from YAML string
+func ErrorEventPayloadFromYAML(yamlStr string) (ErrorEventPayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ErrorEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadErrorEventPayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/error_event_payload_test.go b/runtime/go/prompty/model/error_event_payload_test.go
new file mode 100644
index 00000000..8054ae7b
--- /dev/null
+++ b/runtime/go/prompty/model/error_event_payload_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestErrorEventPayloadLoadJSON tests loading ErrorEventPayload from JSON
+func TestErrorEventPayloadLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "message": "Rate limit exceeded"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorEventPayload: %v", err)
+	}
+	if instance.Message != "Rate limit exceeded" {
+		t.Errorf(`Expected Message to be "Rate limit exceeded", got %v`, instance.Message)
+	}
+}
+
+// TestErrorEventPayloadLoadYAML tests loading ErrorEventPayload from YAML
+func TestErrorEventPayloadLoadYAML(t *testing.T) {
+	yamlData := `
+message: Rate limit exceeded
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorEventPayload: %v", err)
+	}
+	if instance.Message != "Rate limit exceeded" {
+		t.Errorf(`Expected Message to be "Rate limit exceeded", got %v`, instance.Message)
+	}
+}
+
+// TestErrorEventPayloadRoundtrip tests load -> save -> load produces equivalent data
+func TestErrorEventPayloadRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "message": "Rate limit exceeded"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorEventPayload(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorEventPayload: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadErrorEventPayload(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ErrorEventPayload: %v", err)
+	}
+	if reloaded.Message != "Rate limit exceeded" {
+		t.Errorf(`Expected Message to be "Rate limit exceeded", got %v`, reloaded.Message)
+	}
+}
+
+// TestErrorEventPayloadToJSON tests that ToJSON produces valid JSON
+func TestErrorEventPayloadToJSON(t *testing.T) {
+	jsonData := `
+{
+  "message": "Rate limit exceeded"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorEventPayload: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestErrorEventPayloadToYAML tests that ToYAML produces valid YAML
+func TestErrorEventPayloadToYAML(t *testing.T) {
+	jsonData := `
+{
+  "message": "Rate limit exceeded"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadErrorEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ErrorEventPayload: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/executor.go b/runtime/go/prompty/model/executor.go
new file mode 100644
index 00000000..f67ee678
--- /dev/null
+++ b/runtime/go/prompty/model/executor.go
@@ -0,0 +1,14 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+// Executor represents Calls an LLM provider with messages and returns the raw provider response.
+
+type Executor interface {
+	// Execute — Call an LLM provider with messages and return the raw response
+	Execute(agent Prompty, messages []Message) (interface{}, error)
+	// ExecuteStream — Call an LLM provider and return a streaming response. Returns a language-specific async iterable/stream of raw chunks. Not all providers support streaming; the default implementation should signal lack of support.
+	ExecuteStream(agent Prompty, messages []Message) (interface{}, error)
+	// FormatToolMessages — Format tool call results into messages for the next iteration
+	FormatToolMessages(rawResponse interface{}, toolCalls []ToolCall, toolResults []string, textContent *string) ([]Message, error)
+}
diff --git a/runtime/go/prompty/model/file_part_test.go b/runtime/go/prompty/model/file_part_test.go
new file mode 100644
index 00000000..fbcfcea9
--- /dev/null
+++ b/runtime/go/prompty/model/file_part_test.go
@@ -0,0 +1,154 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestFilePartLoadJSON tests loading FilePart from JSON
+func TestFilePartLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/document.pdf",
+  "mediaType": "application/pdf"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadFilePart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load FilePart: %v", err)
+	}
+	if instance.Source != "https://example.com/document.pdf" {
+		t.Errorf(`Expected Source to be "https://example.com/document.pdf", got %v`, instance.Source)
+	}
+	if instance.MediaType == nil || *instance.MediaType != "application/pdf" {
+		t.Errorf(`Expected MediaType to be "application/pdf", got %v`, instance.MediaType)
+	}
+}
+
+// TestFilePartLoadYAML tests loading FilePart from YAML
+func TestFilePartLoadYAML(t *testing.T) {
+	yamlData := `
+source: "https://example.com/document.pdf"
+mediaType: application/pdf
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadFilePart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load FilePart: %v", err)
+	}
+	if instance.Source != "https://example.com/document.pdf" {
+		t.Errorf(`Expected Source to be "https://example.com/document.pdf", got %v`, instance.Source)
+	}
+	if instance.MediaType == nil || *instance.MediaType != "application/pdf" {
+		t.Errorf(`Expected MediaType to be "application/pdf", got %v`, instance.MediaType)
+	}
+}
+
+// TestFilePartRoundtrip tests load -> save -> load produces equivalent data
+func TestFilePartRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/document.pdf",
+  "mediaType": "application/pdf"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadFilePart(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load FilePart: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadFilePart(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload FilePart: %v", err)
+	}
+	if reloaded.Source != "https://example.com/document.pdf" {
+		t.Errorf(`Expected Source to be "https://example.com/document.pdf", got %v`, reloaded.Source)
+	}
+	if reloaded.MediaType == nil || *reloaded.MediaType != "application/pdf" {
+		t.Errorf(`Expected MediaType to be "application/pdf", got %v`, reloaded.MediaType)
+	}
+}
+
+// TestFilePartToJSON tests that ToJSON produces valid JSON
+func TestFilePartToJSON(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/document.pdf",
+  "mediaType": "application/pdf"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadFilePart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load FilePart: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestFilePartToYAML tests that ToYAML produces valid YAML
+func TestFilePartToYAML(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/document.pdf",
+  "mediaType": "application/pdf"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadFilePart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load FilePart: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/format_config_test.go b/runtime/go/prompty/model/format_config_test.go
index df068658..8508deb4 100644
--- a/runtime/go/prompty/model/format_config_test.go
+++ b/runtime/go/prompty/model/format_config_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestFormatConfigLoadJSON tests loading FormatConfig from JSON
diff --git a/runtime/go/prompty/model/foundry_connection_test.go b/runtime/go/prompty/model/foundry_connection_test.go
index 11f8a75b..ec4b88d2 100644
--- a/runtime/go/prompty/model/foundry_connection_test.go
+++ b/runtime/go/prompty/model/foundry_connection_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestFoundryConnectionLoadJSON tests loading FoundryConnection from JSON
diff --git a/runtime/go/prompty/model/function_tool_test.go b/runtime/go/prompty/model/function_tool_test.go
index 1c86bc7d..56b3b4b7 100644
--- a/runtime/go/prompty/model/function_tool_test.go
+++ b/runtime/go/prompty/model/function_tool_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestFunctionToolLoadJSON tests loading FunctionTool from JSON
diff --git a/runtime/go/prompty/model/guardrail_result.go b/runtime/go/prompty/model/guardrail_result.go
new file mode 100644
index 00000000..1ef7b314
--- /dev/null
+++ b/runtime/go/prompty/model/guardrail_result.go
@@ -0,0 +1,111 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// GuardrailResult represents The result of a guardrail evaluation. Guardrails are safety checks that
+// run at specific phases of the agent loop and can allow, deny, or rewrite
+// content.
+
+type GuardrailResult struct {
+	Allowed bool         `json:"allowed" yaml:"allowed"`
+	Reason  *string      `json:"reason,omitempty" yaml:"reason,omitempty"`
+	Rewrite *interface{} `json:"rewrite,omitempty" yaml:"rewrite,omitempty"`
+}
+
+// LoadGuardrailResult creates a GuardrailResult from a map[string]interface{}
+func LoadGuardrailResult(data interface{}, ctx *LoadContext) (GuardrailResult, error) {
+	result := GuardrailResult{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["allowed"]; ok && val != nil {
+			result.Allowed = val.(bool)
+		}
+		if val, ok := m["reason"]; ok && val != nil {
+			v := val.(string)
+			result.Reason = &v
+		}
+		if val, ok := m["rewrite"]; ok && val != nil {
+			result.Rewrite = &val
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes GuardrailResult to map[string]interface{}
+func (obj *GuardrailResult) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["allowed"] = obj.Allowed
+	if obj.Reason != nil {
+		result["reason"] = *obj.Reason
+	}
+	if obj.Rewrite != nil {
+		result["rewrite"] = *obj.Rewrite
+	}
+
+	return result
+}
+
+// ToJSON serializes GuardrailResult to JSON string
+func (obj *GuardrailResult) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes GuardrailResult to YAML string
+func (obj *GuardrailResult) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates GuardrailResult from JSON string
+func GuardrailResultFromJSON(jsonStr string) (GuardrailResult, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return GuardrailResult{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadGuardrailResult(data, ctx)
+}
+
+// FromYAML creates GuardrailResult from YAML string
+func GuardrailResultFromYAML(yamlStr string) (GuardrailResult, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return GuardrailResult{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadGuardrailResult(data, ctx)
+}
+
+// NewRewriteGuardrailResult creates a GuardrailResult with preset field values.
+func NewRewriteGuardrailResult(rewrite interface{}) GuardrailResult {
+	return GuardrailResult{Allowed: true, Rewrite: ptrOf(rewrite)}
+}
+
+// NewDenyGuardrailResult creates a GuardrailResult with preset field values.
+func NewDenyGuardrailResult(reason string) GuardrailResult {
+	return GuardrailResult{Allowed: false, Reason: ptrOf(reason)}
+}
+
+// NewAllowGuardrailResult creates a GuardrailResult with preset field values.
+func NewAllowGuardrailResult() GuardrailResult {
+	return GuardrailResult{Allowed: true}
+}
diff --git a/runtime/go/prompty/model/guardrail_result_test.go b/runtime/go/prompty/model/guardrail_result_test.go
new file mode 100644
index 00000000..55b29ac8
--- /dev/null
+++ b/runtime/go/prompty/model/guardrail_result_test.go
@@ -0,0 +1,154 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestGuardrailResultLoadJSON tests loading GuardrailResult from JSON
+func TestGuardrailResultLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "allowed": true,
+  "reason": "Content is safe"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadGuardrailResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load GuardrailResult: %v", err)
+	}
+	if instance.Allowed != true {
+		t.Errorf(`Expected Allowed to be true, got %v`, instance.Allowed)
+	}
+	if instance.Reason == nil || *instance.Reason != "Content is safe" {
+		t.Errorf(`Expected Reason to be "Content is safe", got %v`, instance.Reason)
+	}
+}
+
+// TestGuardrailResultLoadYAML tests loading GuardrailResult from YAML
+func TestGuardrailResultLoadYAML(t *testing.T) {
+	yamlData := `
+allowed: true
+reason: Content is safe
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadGuardrailResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load GuardrailResult: %v", err)
+	}
+	if instance.Allowed != true {
+		t.Errorf(`Expected Allowed to be true, got %v`, instance.Allowed)
+	}
+	if instance.Reason == nil || *instance.Reason != "Content is safe" {
+		t.Errorf(`Expected Reason to be "Content is safe", got %v`, instance.Reason)
+	}
+}
+
+// TestGuardrailResultRoundtrip tests load -> save -> load produces equivalent data
+func TestGuardrailResultRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "allowed": true,
+  "reason": "Content is safe"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadGuardrailResult(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load GuardrailResult: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadGuardrailResult(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload GuardrailResult: %v", err)
+	}
+	if reloaded.Allowed != true {
+		t.Errorf(`Expected Allowed to be true, got %v`, reloaded.Allowed)
+	}
+	if reloaded.Reason == nil || *reloaded.Reason != "Content is safe" {
+		t.Errorf(`Expected Reason to be "Content is safe", got %v`, reloaded.Reason)
+	}
+}
+
+// TestGuardrailResultToJSON tests that ToJSON produces valid JSON
+func TestGuardrailResultToJSON(t *testing.T) {
+	jsonData := `
+{
+  "allowed": true,
+  "reason": "Content is safe"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadGuardrailResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load GuardrailResult: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestGuardrailResultToYAML tests that ToYAML produces valid YAML
+func TestGuardrailResultToYAML(t *testing.T) {
+	jsonData := `
+{
+  "allowed": true,
+  "reason": "Content is safe"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadGuardrailResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load GuardrailResult: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/helpers.go b/runtime/go/prompty/model/helpers.go
new file mode 100644
index 00000000..ab742a16
--- /dev/null
+++ b/runtime/go/prompty/model/helpers.go
@@ -0,0 +1,33 @@
+// Hand-written helper methods for generated model types.
+// Implements the MessageHelpers and ToolResultHelpers interfaces
+// declared by the TypeSpec emitter.
+
+package prompty
+
+import "strings"
+
+// Text concatenates all TextPart values in the message, joined by newline.
+func (m *Message) Text() string {
+	var texts []string
+	for _, part := range m.Parts {
+		if tp, ok := part.(TextPart); ok {
+			texts = append(texts, tp.Value)
+		} else if ptr, ok := part.(*TextPart); ok {
+			texts = append(texts, ptr.Value)
+		}
+	}
+	return strings.Join(texts, "\n")
+}
+
+// Text concatenates all TextPart values in the tool result, joined by newline.
+func (tr *ToolResult) Text() string {
+	var texts []string
+	for _, part := range tr.Parts {
+		if tp, ok := part.(TextPart); ok {
+			texts = append(texts, tp.Value)
+		} else if ptr, ok := part.(*TextPart); ok {
+			texts = append(texts, ptr.Value)
+		}
+	}
+	return strings.Join(texts, "\n")
+}
diff --git a/runtime/go/prompty/model/image_part_test.go b/runtime/go/prompty/model/image_part_test.go
new file mode 100644
index 00000000..f3b104ac
--- /dev/null
+++ b/runtime/go/prompty/model/image_part_test.go
@@ -0,0 +1,168 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestImagePartLoadJSON tests loading ImagePart from JSON
+func TestImagePartLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/image.png",
+  "detail": "auto",
+  "mediaType": "image/png"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadImagePart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ImagePart: %v", err)
+	}
+	if instance.Source != "https://example.com/image.png" {
+		t.Errorf(`Expected Source to be "https://example.com/image.png", got %v`, instance.Source)
+	}
+	if instance.Detail == nil || *instance.Detail != "auto" {
+		t.Errorf(`Expected Detail to be "auto", got %v`, instance.Detail)
+	}
+	if instance.MediaType == nil || *instance.MediaType != "image/png" {
+		t.Errorf(`Expected MediaType to be "image/png", got %v`, instance.MediaType)
+	}
+}
+
+// TestImagePartLoadYAML tests loading ImagePart from YAML
+func TestImagePartLoadYAML(t *testing.T) {
+	yamlData := `
+source: "https://example.com/image.png"
+detail: auto
+mediaType: image/png
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadImagePart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ImagePart: %v", err)
+	}
+	if instance.Source != "https://example.com/image.png" {
+		t.Errorf(`Expected Source to be "https://example.com/image.png", got %v`, instance.Source)
+	}
+	if instance.Detail == nil || *instance.Detail != "auto" {
+		t.Errorf(`Expected Detail to be "auto", got %v`, instance.Detail)
+	}
+	if instance.MediaType == nil || *instance.MediaType != "image/png" {
+		t.Errorf(`Expected MediaType to be "image/png", got %v`, instance.MediaType)
+	}
+}
+
+// TestImagePartRoundtrip tests load -> save -> load produces equivalent data
+func TestImagePartRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/image.png",
+  "detail": "auto",
+  "mediaType": "image/png"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadImagePart(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ImagePart: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadImagePart(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ImagePart: %v", err)
+	}
+	if reloaded.Source != "https://example.com/image.png" {
+		t.Errorf(`Expected Source to be "https://example.com/image.png", got %v`, reloaded.Source)
+	}
+	if reloaded.Detail == nil || *reloaded.Detail != "auto" {
+		t.Errorf(`Expected Detail to be "auto", got %v`, reloaded.Detail)
+	}
+	if reloaded.MediaType == nil || *reloaded.MediaType != "image/png" {
+		t.Errorf(`Expected MediaType to be "image/png", got %v`, reloaded.MediaType)
+	}
+}
+
+// TestImagePartToJSON tests that ToJSON produces valid JSON
+func TestImagePartToJSON(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/image.png",
+  "detail": "auto",
+  "mediaType": "image/png"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadImagePart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ImagePart: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestImagePartToYAML tests that ToYAML produces valid YAML
+func TestImagePartToYAML(t *testing.T) {
+	jsonData := `
+{
+  "source": "https://example.com/image.png",
+  "detail": "auto",
+  "mediaType": "image/png"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadImagePart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ImagePart: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/mcp_approval_mode_test.go b/runtime/go/prompty/model/mcp_approval_mode_test.go
index 92131fe4..a81a5f72 100644
--- a/runtime/go/prompty/model/mcp_approval_mode_test.go
+++ b/runtime/go/prompty/model/mcp_approval_mode_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestMcpApprovalModeLoadJSON tests loading McpApprovalMode from JSON
diff --git a/runtime/go/prompty/model/mcp_tool_test.go b/runtime/go/prompty/model/mcp_tool_test.go
index 29667d5f..83b488ff 100644
--- a/runtime/go/prompty/model/mcp_tool_test.go
+++ b/runtime/go/prompty/model/mcp_tool_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestMcpToolLoadJSON tests loading McpTool from JSON
diff --git a/runtime/go/prompty/model/message.go b/runtime/go/prompty/model/message.go
new file mode 100644
index 00000000..4d3f09e5
--- /dev/null
+++ b/runtime/go/prompty/model/message.go
@@ -0,0 +1,139 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// Message represents A message in a conversation. Messages have a role and a list of content parts
+// representing the different modalities of the message content.
+
+type Message struct {
+	Role     string                 `json:"role" yaml:"role"`
+	Parts    []interface{}          `json:"parts" yaml:"parts"`
+	Metadata map[string]interface{} `json:"metadata" yaml:"metadata"`
+}
+
+// LoadMessage creates a Message from a map[string]interface{}
+func LoadMessage(data interface{}, ctx *LoadContext) (Message, error) {
+	result := Message{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["role"]; ok && val != nil {
+			result.Role = val.(string)
+		}
+		if val, ok := m["parts"]; ok && val != nil {
+			if arr, ok := val.([]interface{}); ok {
+				result.Parts = make([]interface{}, len(arr))
+				for i, v := range arr {
+					if item, ok := v.(map[string]interface{}); ok {
+						loaded, _ := LoadContentPart(item, ctx)
+						// Polymorphic type - store as interface{}
+						result.Parts[i] = loaded
+					}
+				}
+			}
+		}
+		if val, ok := m["metadata"]; ok && val != nil {
+			if m, ok := val.(map[string]interface{}); ok {
+				result.Metadata = m
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes Message to map[string]interface{}
+func (obj *Message) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["role"] = obj.Role
+	if obj.Parts != nil {
+		arr := make([]interface{}, len(obj.Parts))
+		for i, item := range obj.Parts {
+			// Handle polymorphic type via type switch
+			switch v := item.(type) {
+			case interface {
+				Save(*SaveContext) map[string]interface{}
+			}:
+				arr[i] = v.Save(ctx)
+			default:
+				arr[i] = item
+			}
+		}
+		result["parts"] = arr
+	}
+	result["metadata"] = obj.Metadata
+
+	return result
+}
+
+// ToJSON serializes Message to JSON string
+func (obj *Message) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes Message to YAML string
+func (obj *Message) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates Message from JSON string
+func MessageFromJSON(jsonStr string) (Message, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return Message{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadMessage(data, ctx)
+}
+
+// FromYAML creates Message from YAML string
+func MessageFromYAML(yamlStr string) (Message, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return Message{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadMessage(data, ctx)
+}
+
+// NewAssistantMessage creates a Message with preset field values.
+func NewAssistantMessage(text string) Message {
+	return Message{Role: "assistant", Parts: []interface{}{TextPart{Kind: "text", Value: text}}}
+}
+
+// NewSystemMessage creates a Message with preset field values.
+func NewSystemMessage(text string) Message {
+	return Message{Role: "system", Parts: []interface{}{TextPart{Kind: "text", Value: text}}}
+}
+
+// NewUserMessage creates a Message with preset field values.
+func NewUserMessage(text string) Message {
+	return Message{Role: "user", Parts: []interface{}{TextPart{Kind: "text", Value: text}}}
+}
+
+// MessageHelpers defines helper methods for Message.
+// Implement these in a separate file (e.g., message_helpers.go).
+type MessageHelpers interface {
+	// ToTextContent — Return plain string if all parts are text, else a list of content part dicts for wire serialization
+	ToTextContent() interface{}
+	// Text — Concatenate all TextPart values joined by newline
+	Text() string
+}
diff --git a/runtime/go/prompty/model/message_test.go b/runtime/go/prompty/model/message_test.go
new file mode 100644
index 00000000..3e22ff39
--- /dev/null
+++ b/runtime/go/prompty/model/message_test.go
@@ -0,0 +1,181 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestMessageLoadJSON tests loading Message from JSON
+func TestMessageLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "role": "user",
+  "parts": [
+    {
+      "kind": "text",
+      "value": "Hello!"
+    }
+  ],
+  "metadata": {
+    "source": "user-input"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadMessage(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load Message: %v", err)
+	}
+	if instance.Role != "user" {
+		t.Errorf(`Expected Role to be "user", got %v`, instance.Role)
+	}
+}
+
+// TestMessageLoadYAML tests loading Message from YAML
+func TestMessageLoadYAML(t *testing.T) {
+	yamlData := `
+role: user
+parts:
+  - kind: text
+    value: Hello!
+metadata:
+  source: user-input
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadMessage(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load Message: %v", err)
+	}
+	if instance.Role != "user" {
+		t.Errorf(`Expected Role to be "user", got %v`, instance.Role)
+	}
+}
+
+// TestMessageRoundtrip tests load -> save -> load produces equivalent data
+func TestMessageRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "role": "user",
+  "parts": [
+    {
+      "kind": "text",
+      "value": "Hello!"
+    }
+  ],
+  "metadata": {
+    "source": "user-input"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadMessage(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load Message: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadMessage(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload Message: %v", err)
+	}
+	if reloaded.Role != "user" {
+		t.Errorf(`Expected Role to be "user", got %v`, reloaded.Role)
+	}
+}
+
+// TestMessageToJSON tests that ToJSON produces valid JSON
+func TestMessageToJSON(t *testing.T) {
+	jsonData := `
+{
+  "role": "user",
+  "parts": [
+    {
+      "kind": "text",
+      "value": "Hello!"
+    }
+  ],
+  "metadata": {
+    "source": "user-input"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadMessage(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load Message: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestMessageToYAML tests that ToYAML produces valid YAML
+func TestMessageToYAML(t *testing.T) {
+	jsonData := `
+{
+  "role": "user",
+  "parts": [
+    {
+      "kind": "text",
+      "value": "Hello!"
+    }
+  ],
+  "metadata": {
+    "source": "user-input"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadMessage(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load Message: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/messages_updated_payload.go b/runtime/go/prompty/model/messages_updated_payload.go
new file mode 100644
index 00000000..85486779
--- /dev/null
+++ b/runtime/go/prompty/model/messages_updated_payload.go
@@ -0,0 +1,93 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// MessagesUpdatedPayload represents Payload for "messages_updated" events — the conversation state has changed.
+
+type MessagesUpdatedPayload struct {
+	Messages []Message `json:"messages" yaml:"messages"`
+}
+
+// LoadMessagesUpdatedPayload creates a MessagesUpdatedPayload from a map[string]interface{}
+func LoadMessagesUpdatedPayload(data interface{}, ctx *LoadContext) (MessagesUpdatedPayload, error) {
+	result := MessagesUpdatedPayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["messages"]; ok && val != nil {
+			if arr, ok := val.([]interface{}); ok {
+				result.Messages = make([]Message, len(arr))
+				for i, v := range arr {
+					if item, ok := v.(map[string]interface{}); ok {
+						loaded, _ := LoadMessage(item, ctx)
+						result.Messages[i] = loaded
+					}
+				}
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes MessagesUpdatedPayload to map[string]interface{}
+func (obj *MessagesUpdatedPayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	if obj.Messages != nil {
+		arr := make([]interface{}, len(obj.Messages))
+		for i, item := range obj.Messages {
+			arr[i] = item.Save(ctx)
+		}
+		result["messages"] = arr
+	}
+
+	return result
+}
+
+// ToJSON serializes MessagesUpdatedPayload to JSON string
+func (obj *MessagesUpdatedPayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes MessagesUpdatedPayload to YAML string
+func (obj *MessagesUpdatedPayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates MessagesUpdatedPayload from JSON string
+func MessagesUpdatedPayloadFromJSON(jsonStr string) (MessagesUpdatedPayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return MessagesUpdatedPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadMessagesUpdatedPayload(data, ctx)
+}
+
+// FromYAML creates MessagesUpdatedPayload from YAML string
+func MessagesUpdatedPayloadFromYAML(yamlStr string) (MessagesUpdatedPayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return MessagesUpdatedPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadMessagesUpdatedPayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/messages_updated_payload_test.go b/runtime/go/prompty/model/messages_updated_payload_test.go
new file mode 100644
index 00000000..8e719bf5
--- /dev/null
+++ b/runtime/go/prompty/model/messages_updated_payload_test.go
@@ -0,0 +1,3 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
diff --git a/runtime/go/prompty/model/model_info.go b/runtime/go/prompty/model/model_info.go
new file mode 100644
index 00000000..917a4990
--- /dev/null
+++ b/runtime/go/prompty/model/model_info.go
@@ -0,0 +1,147 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ModelInfo represents Information about a model available from a provider. Used by provider-level
+// model discovery to report which models are available and their capabilities.
+//
+// Not all providers return all fields — implementations SHOULD populate as
+// many fields as the provider's API supports and MAY enrich sparse results
+// from a built-in lookup table of known models.
+
+type ModelInfo struct {
+	Id                   string                 `json:"id" yaml:"id"`
+	DisplayName          *string                `json:"displayName,omitempty" yaml:"displayName,omitempty"`
+	OwnedBy              *string                `json:"ownedBy,omitempty" yaml:"ownedBy,omitempty"`
+	ContextWindow        *int32                 `json:"contextWindow,omitempty" yaml:"contextWindow,omitempty"`
+	InputModalities      []string               `json:"inputModalities,omitempty" yaml:"inputModalities,omitempty"`
+	OutputModalities     []string               `json:"outputModalities,omitempty" yaml:"outputModalities,omitempty"`
+	AdditionalProperties map[string]interface{} `json:"additionalProperties,omitempty" yaml:"additionalProperties,omitempty"`
+}
+
+// LoadModelInfo creates a ModelInfo from a map[string]interface{}
+func LoadModelInfo(data interface{}, ctx *LoadContext) (ModelInfo, error) {
+	result := ModelInfo{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["id"]; ok && val != nil {
+			result.Id = val.(string)
+		}
+		if val, ok := m["displayName"]; ok && val != nil {
+			v := val.(string)
+			result.DisplayName = &v
+		}
+		if val, ok := m["ownedBy"]; ok && val != nil {
+			v := val.(string)
+			result.OwnedBy = &v
+		}
+		if val, ok := m["contextWindow"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.ContextWindow = &v
+		}
+		if val, ok := m["inputModalities"]; ok && val != nil {
+			if arr, ok := val.([]interface{}); ok {
+				result.InputModalities = make([]string, len(arr))
+				for i, v := range arr {
+					result.InputModalities[i] = v.(string)
+				}
+			}
+		}
+		if val, ok := m["outputModalities"]; ok && val != nil {
+			if arr, ok := val.([]interface{}); ok {
+				result.OutputModalities = make([]string, len(arr))
+				for i, v := range arr {
+					result.OutputModalities[i] = v.(string)
+				}
+			}
+		}
+		if val, ok := m["additionalProperties"]; ok && val != nil {
+			if m, ok := val.(map[string]interface{}); ok {
+				result.AdditionalProperties = m
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ModelInfo to map[string]interface{}
+func (obj *ModelInfo) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["id"] = obj.Id
+	if obj.DisplayName != nil {
+		result["displayName"] = *obj.DisplayName
+	}
+	if obj.OwnedBy != nil {
+		result["ownedBy"] = *obj.OwnedBy
+	}
+	if obj.ContextWindow != nil {
+		result["contextWindow"] = *obj.ContextWindow
+	}
+	result["inputModalities"] = obj.InputModalities
+	result["outputModalities"] = obj.OutputModalities
+	if obj.AdditionalProperties != nil {
+		result["additionalProperties"] = obj.AdditionalProperties
+	}
+
+	return result
+}
+
+// ToJSON serializes ModelInfo to JSON string
+func (obj *ModelInfo) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ModelInfo to YAML string
+func (obj *ModelInfo) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ModelInfo from JSON string
+func ModelInfoFromJSON(jsonStr string) (ModelInfo, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ModelInfo{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadModelInfo(data, ctx)
+}
+
+// FromYAML creates ModelInfo from YAML string
+func ModelInfoFromYAML(yamlStr string) (ModelInfo, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ModelInfo{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadModelInfo(data, ctx)
+}
diff --git a/runtime/go/prompty/model/model_info_test.go b/runtime/go/prompty/model/model_info_test.go
new file mode 100644
index 00000000..5bebaf6a
--- /dev/null
+++ b/runtime/go/prompty/model/model_info_test.go
@@ -0,0 +1,229 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestModelInfoLoadJSON tests loading ModelInfo from JSON
+func TestModelInfoLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "id": "gpt-4o",
+  "displayName": "GPT-4o",
+  "ownedBy": "openai",
+  "contextWindow": 128000,
+  "inputModalities": [
+    "text",
+    "image"
+  ],
+  "outputModalities": [
+    "text"
+  ],
+  "additionalProperties": {
+    "supportsStreaming": true
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadModelInfo(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ModelInfo: %v", err)
+	}
+	if instance.Id != "gpt-4o" {
+		t.Errorf(`Expected Id to be "gpt-4o", got %v`, instance.Id)
+	}
+	if instance.DisplayName == nil || *instance.DisplayName != "GPT-4o" {
+		t.Errorf(`Expected DisplayName to be "GPT-4o", got %v`, instance.DisplayName)
+	}
+	if instance.OwnedBy == nil || *instance.OwnedBy != "openai" {
+		t.Errorf(`Expected OwnedBy to be "openai", got %v`, instance.OwnedBy)
+	}
+	if instance.ContextWindow == nil || *instance.ContextWindow != 128000 {
+		t.Errorf(`Expected ContextWindow to be 128000, got %v`, instance.ContextWindow)
+	}
+}
+
+// TestModelInfoLoadYAML tests loading ModelInfo from YAML
+func TestModelInfoLoadYAML(t *testing.T) {
+	yamlData := `
+id: gpt-4o
+displayName: GPT-4o
+ownedBy: openai
+contextWindow: 128000
+inputModalities:
+  - text
+  - image
+outputModalities:
+  - text
+additionalProperties:
+  supportsStreaming: true
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadModelInfo(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ModelInfo: %v", err)
+	}
+	if instance.Id != "gpt-4o" {
+		t.Errorf(`Expected Id to be "gpt-4o", got %v`, instance.Id)
+	}
+	if instance.DisplayName == nil || *instance.DisplayName != "GPT-4o" {
+		t.Errorf(`Expected DisplayName to be "GPT-4o", got %v`, instance.DisplayName)
+	}
+	if instance.OwnedBy == nil || *instance.OwnedBy != "openai" {
+		t.Errorf(`Expected OwnedBy to be "openai", got %v`, instance.OwnedBy)
+	}
+	if instance.ContextWindow == nil || *instance.ContextWindow != 128000 {
+		t.Errorf(`Expected ContextWindow to be 128000, got %v`, instance.ContextWindow)
+	}
+}
+
+// TestModelInfoRoundtrip tests load -> save -> load produces equivalent data
+func TestModelInfoRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "id": "gpt-4o",
+  "displayName": "GPT-4o",
+  "ownedBy": "openai",
+  "contextWindow": 128000,
+  "inputModalities": [
+    "text",
+    "image"
+  ],
+  "outputModalities": [
+    "text"
+  ],
+  "additionalProperties": {
+    "supportsStreaming": true
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadModelInfo(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ModelInfo: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadModelInfo(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ModelInfo: %v", err)
+	}
+	if reloaded.Id != "gpt-4o" {
+		t.Errorf(`Expected Id to be "gpt-4o", got %v`, reloaded.Id)
+	}
+	if reloaded.DisplayName == nil || *reloaded.DisplayName != "GPT-4o" {
+		t.Errorf(`Expected DisplayName to be "GPT-4o", got %v`, reloaded.DisplayName)
+	}
+	if reloaded.OwnedBy == nil || *reloaded.OwnedBy != "openai" {
+		t.Errorf(`Expected OwnedBy to be "openai", got %v`, reloaded.OwnedBy)
+	}
+	if reloaded.ContextWindow == nil || *reloaded.ContextWindow != 128000 {
+		t.Errorf(`Expected ContextWindow to be 128000, got %v`, reloaded.ContextWindow)
+	}
+}
+
+// TestModelInfoToJSON tests that ToJSON produces valid JSON
+func TestModelInfoToJSON(t *testing.T) {
+	jsonData := `
+{
+  "id": "gpt-4o",
+  "displayName": "GPT-4o",
+  "ownedBy": "openai",
+  "contextWindow": 128000,
+  "inputModalities": [
+    "text",
+    "image"
+  ],
+  "outputModalities": [
+    "text"
+  ],
+  "additionalProperties": {
+    "supportsStreaming": true
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadModelInfo(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ModelInfo: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestModelInfoToYAML tests that ToYAML produces valid YAML
+func TestModelInfoToYAML(t *testing.T) {
+	jsonData := `
+{
+  "id": "gpt-4o",
+  "displayName": "GPT-4o",
+  "ownedBy": "openai",
+  "contextWindow": 128000,
+  "inputModalities": [
+    "text",
+    "image"
+  ],
+  "outputModalities": [
+    "text"
+  ],
+  "additionalProperties": {
+    "supportsStreaming": true
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadModelInfo(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ModelInfo: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/model_options.go b/runtime/go/prompty/model/model_options.go
index 643f7b99..1a8bef2b 100644
--- a/runtime/go/prompty/model/model_options.go
+++ b/runtime/go/prompty/model/model_options.go
@@ -192,6 +192,31 @@ func (obj *ModelOptions) Save(ctx *SaveContext) map[string]interface{} {
 	return result
 }
 
+// ToWire converts to provider-specific wire format.
+func (obj *ModelOptions) ToWire(provider string) map[string]interface{} {
+	data := obj.Save(nil)
+	result := make(map[string]interface{})
+	wireMap := map[string]map[string]string{
+		"frequencyPenalty":       {"openai": "frequency_penalty"},
+		"maxOutputTokens":        {"openai": "max_completion_tokens", "responses": "max_output_tokens", "anthropic": "max_tokens"},
+		"presencePenalty":        {"openai": "presence_penalty"},
+		"seed":                   {"openai": "seed"},
+		"temperature":            {"openai": "temperature", "responses": "temperature", "anthropic": "temperature"},
+		"topK":                   {"openai": "top_k", "anthropic": "top_k"},
+		"topP":                   {"openai": "top_p", "responses": "top_p", "anthropic": "top_p"},
+		"stopSequences":          {"openai": "stop", "anthropic": "stop_sequences"},
+		"allowMultipleToolCalls": {"openai": "parallel_tool_calls"},
+	}
+	for key, value := range data {
+		if mapping, ok := wireMap[key]; ok {
+			if wireName, ok := mapping[provider]; ok {
+				result[wireName] = value
+			}
+		}
+	}
+	return result
+}
+
 // ToJSON serializes ModelOptions to JSON string
 func (obj *ModelOptions) ToJSON() (string, error) {
 	ctx := NewSaveContext()
diff --git a/runtime/go/prompty/model/model_options_test.go b/runtime/go/prompty/model/model_options_test.go
index e21925ef..dc698a3b 100644
--- a/runtime/go/prompty/model/model_options_test.go
+++ b/runtime/go/prompty/model/model_options_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestModelOptionsLoadJSON tests loading ModelOptions from JSON
diff --git a/runtime/go/prompty/model/model_test.go b/runtime/go/prompty/model/model_test.go
index 7182e635..e27d2c57 100644
--- a/runtime/go/prompty/model/model_test.go
+++ b/runtime/go/prompty/model/model_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestModelLoadJSON tests loading Model from JSON
diff --git a/runtime/go/prompty/model/o_auth_connection_test.go b/runtime/go/prompty/model/o_auth_connection_test.go
index 64dee97d..f6d94011 100644
--- a/runtime/go/prompty/model/o_auth_connection_test.go
+++ b/runtime/go/prompty/model/o_auth_connection_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestOAuthConnectionLoadJSON tests loading OAuthConnection from JSON
diff --git a/runtime/go/prompty/model/object_property_test.go b/runtime/go/prompty/model/object_property_test.go
index 294e78c0..e13b53f8 100644
--- a/runtime/go/prompty/model/object_property_test.go
+++ b/runtime/go/prompty/model/object_property_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestObjectPropertyLoadJSON tests loading ObjectProperty from JSON
diff --git a/runtime/go/prompty/model/open_api_tool_test.go b/runtime/go/prompty/model/open_api_tool_test.go
index 2322b4e1..4616269e 100644
--- a/runtime/go/prompty/model/open_api_tool_test.go
+++ b/runtime/go/prompty/model/open_api_tool_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestOpenApiToolLoadJSON tests loading OpenApiTool from JSON
diff --git a/runtime/go/prompty/model/parser.go b/runtime/go/prompty/model/parser.go
new file mode 100644
index 00000000..5ab22509
--- /dev/null
+++ b/runtime/go/prompty/model/parser.go
@@ -0,0 +1,12 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+// Parser represents Parses rendered prompt text into an array of structured messages with role markers.
+
+type Parser interface {
+	// PreRender — Pre-process a template before rendering, returning modified template and context
+	PreRender(template string) *interface{}
+	// Parse — Parse rendered text into a structured message array
+	Parse(agent Prompty, rendered string, context *map[string]interface{}) ([]Message, error)
+}
diff --git a/runtime/go/prompty/model/parser_config_test.go b/runtime/go/prompty/model/parser_config_test.go
index 59c10747..b2c053db 100644
--- a/runtime/go/prompty/model/parser_config_test.go
+++ b/runtime/go/prompty/model/parser_config_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestParserConfigLoadJSON tests loading ParserConfig from JSON
diff --git a/runtime/go/prompty/model/processor.go b/runtime/go/prompty/model/processor.go
new file mode 100644
index 00000000..39f431f4
--- /dev/null
+++ b/runtime/go/prompty/model/processor.go
@@ -0,0 +1,12 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+// Processor represents Extracts a clean, typed result from a raw LLM provider response.
+
+type Processor interface {
+	// Process — Extract a clean result from a raw LLM response
+	Process(agent Prompty, response interface{}) (interface{}, error)
+	// ProcessStream — Process a streaming response into a stream of StreamChunk items. Takes raw chunks from the executor and yields processed text, thinking, tool, or error chunks. Not all providers support streaming; the default implementation should signal lack of support.
+	ProcessStream(stream interface{}) (interface{}, error)
+}
diff --git a/runtime/go/prompty/model/prompty_test.go b/runtime/go/prompty/model/prompty_test.go
index 7f4d2260..40a0aa56 100644
--- a/runtime/go/prompty/model/prompty_test.go
+++ b/runtime/go/prompty/model/prompty_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestPromptyLoadJSON tests loading Prompty from JSON
diff --git a/runtime/go/prompty/model/prompty_tool_test.go b/runtime/go/prompty/model/prompty_tool_test.go
index 880a7efe..039cee1b 100644
--- a/runtime/go/prompty/model/prompty_tool_test.go
+++ b/runtime/go/prompty/model/prompty_tool_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestPromptyToolLoadJSON tests loading PromptyTool from JSON
diff --git a/runtime/go/prompty/model/property_test.go b/runtime/go/prompty/model/property_test.go
index a943f8f1..c7871a7e 100644
--- a/runtime/go/prompty/model/property_test.go
+++ b/runtime/go/prompty/model/property_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestPropertyLoadJSON tests loading Property from JSON
diff --git a/runtime/go/prompty/model/reference_connection_test.go b/runtime/go/prompty/model/reference_connection_test.go
index 7914fbc1..2a798c4a 100644
--- a/runtime/go/prompty/model/reference_connection_test.go
+++ b/runtime/go/prompty/model/reference_connection_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestReferenceConnectionLoadJSON tests loading ReferenceConnection from JSON
diff --git a/runtime/go/prompty/model/remote_connection_test.go b/runtime/go/prompty/model/remote_connection_test.go
index 77e598a4..2599b621 100644
--- a/runtime/go/prompty/model/remote_connection_test.go
+++ b/runtime/go/prompty/model/remote_connection_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestRemoteConnectionLoadJSON tests loading RemoteConnection from JSON
diff --git a/runtime/go/prompty/model/renderer.go b/runtime/go/prompty/model/renderer.go
new file mode 100644
index 00000000..e1e5c268
--- /dev/null
+++ b/runtime/go/prompty/model/renderer.go
@@ -0,0 +1,10 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+// Renderer represents Renders a template string with input values to produce the final prompt text.
+
+type Renderer interface {
+	// Render — Render the template string with input values
+	Render(agent Prompty, template string, inputs map[string]interface{}) (string, error)
+}
diff --git a/runtime/go/prompty/model/status_event_payload.go b/runtime/go/prompty/model/status_event_payload.go
new file mode 100644
index 00000000..985181e3
--- /dev/null
+++ b/runtime/go/prompty/model/status_event_payload.go
@@ -0,0 +1,79 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// StatusEventPayload represents Payload for "status" events — informational messages about loop progress.
+
+type StatusEventPayload struct {
+	Message string `json:"message" yaml:"message"`
+}
+
+// LoadStatusEventPayload creates a StatusEventPayload from a map[string]interface{}
+func LoadStatusEventPayload(data interface{}, ctx *LoadContext) (StatusEventPayload, error) {
+	result := StatusEventPayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["message"]; ok && val != nil {
+			result.Message = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes StatusEventPayload to map[string]interface{}
+func (obj *StatusEventPayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["message"] = obj.Message
+
+	return result
+}
+
+// ToJSON serializes StatusEventPayload to JSON string
+func (obj *StatusEventPayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes StatusEventPayload to YAML string
+func (obj *StatusEventPayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates StatusEventPayload from JSON string
+func StatusEventPayloadFromJSON(jsonStr string) (StatusEventPayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return StatusEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadStatusEventPayload(data, ctx)
+}
+
+// FromYAML creates StatusEventPayload from YAML string
+func StatusEventPayloadFromYAML(yamlStr string) (StatusEventPayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return StatusEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadStatusEventPayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/status_event_payload_test.go b/runtime/go/prompty/model/status_event_payload_test.go
new file mode 100644
index 00000000..41c8950a
--- /dev/null
+++ b/runtime/go/prompty/model/status_event_payload_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestStatusEventPayloadLoadJSON tests loading StatusEventPayload from JSON
+func TestStatusEventPayloadLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "message": "Starting iteration 3"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadStatusEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load StatusEventPayload: %v", err)
+	}
+	if instance.Message != "Starting iteration 3" {
+		t.Errorf(`Expected Message to be "Starting iteration 3", got %v`, instance.Message)
+	}
+}
+
+// TestStatusEventPayloadLoadYAML tests loading StatusEventPayload from YAML
+func TestStatusEventPayloadLoadYAML(t *testing.T) {
+	yamlData := `
+message: Starting iteration 3
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadStatusEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load StatusEventPayload: %v", err)
+	}
+	if instance.Message != "Starting iteration 3" {
+		t.Errorf(`Expected Message to be "Starting iteration 3", got %v`, instance.Message)
+	}
+}
+
+// TestStatusEventPayloadRoundtrip tests load -> save -> load produces equivalent data
+func TestStatusEventPayloadRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "message": "Starting iteration 3"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadStatusEventPayload(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load StatusEventPayload: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadStatusEventPayload(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload StatusEventPayload: %v", err)
+	}
+	if reloaded.Message != "Starting iteration 3" {
+		t.Errorf(`Expected Message to be "Starting iteration 3", got %v`, reloaded.Message)
+	}
+}
+
+// TestStatusEventPayloadToJSON tests that ToJSON produces valid JSON
+func TestStatusEventPayloadToJSON(t *testing.T) {
+	jsonData := `
+{
+  "message": "Starting iteration 3"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadStatusEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load StatusEventPayload: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestStatusEventPayloadToYAML tests that ToYAML produces valid YAML
+func TestStatusEventPayloadToYAML(t *testing.T) {
+	jsonData := `
+{
+  "message": "Starting iteration 3"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadStatusEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load StatusEventPayload: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/stream_chunk.go b/runtime/go/prompty/model/stream_chunk.go
new file mode 100644
index 00000000..a881c2c4
--- /dev/null
+++ b/runtime/go/prompty/model/stream_chunk.go
@@ -0,0 +1,402 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// StreamChunk represents A chunk of data from a streaming LLM response. Stream chunks are
+// discriminated on the `kind` field.
+
+type StreamChunk struct {
+	Kind string `json:"kind" yaml:"kind"`
+}
+
+// LoadStreamChunk creates a StreamChunk from a map[string]interface{}
+// Returns interface{} because this is a polymorphic base type that can resolve to different child types
+func LoadStreamChunk(data interface{}, ctx *LoadContext) (interface{}, error) {
+	result := StreamChunk{}
+
+	// Handle polymorphic types based on discriminator
+	if m, ok := data.(map[string]interface{}); ok {
+		if discriminator, ok := m["kind"]; ok {
+			switch discriminator {
+			case "text":
+				return LoadTextChunk(data, ctx)
+			case "thinking":
+				return LoadThinkingChunk(data, ctx)
+			case "tool":
+				return LoadToolChunk(data, ctx)
+			case "error":
+				return LoadErrorChunk(data, ctx)
+			}
+		}
+	}
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes StreamChunk to map[string]interface{}
+func (obj *StreamChunk) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+
+	return result
+}
+
+// ToJSON serializes StreamChunk to JSON string
+func (obj *StreamChunk) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes StreamChunk to YAML string
+func (obj *StreamChunk) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates StreamChunk from JSON string
+// Returns interface{} because this is a polymorphic base type that can resolve to different child types
+func StreamChunkFromJSON(jsonStr string) (interface{}, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return nil, err
+	}
+	ctx := NewLoadContext()
+	return LoadStreamChunk(data, ctx)
+}
+
+// FromYAML creates StreamChunk from YAML string
+// Returns interface{} because this is a polymorphic base type that can resolve to different child types
+func StreamChunkFromYAML(yamlStr string) (interface{}, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return nil, err
+	}
+	ctx := NewLoadContext()
+	return LoadStreamChunk(data, ctx)
+}
+
+// TextChunk represents A text content chunk from the LLM response stream.
+
+type TextChunk struct {
+	Kind  string `json:"kind" yaml:"kind"`
+	Value string `json:"value" yaml:"value"`
+}
+
+// LoadTextChunk creates a TextChunk from a map[string]interface{}
+func LoadTextChunk(data interface{}, ctx *LoadContext) (TextChunk, error) {
+	result := TextChunk{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+		if val, ok := m["value"]; ok && val != nil {
+			result.Value = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes TextChunk to map[string]interface{}
+func (obj *TextChunk) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+	result["value"] = obj.Value
+
+	return result
+}
+
+// ToJSON serializes TextChunk to JSON string
+func (obj *TextChunk) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes TextChunk to YAML string
+func (obj *TextChunk) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates TextChunk from JSON string
+func TextChunkFromJSON(jsonStr string) (TextChunk, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return TextChunk{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTextChunk(data, ctx)
+}
+
+// FromYAML creates TextChunk from YAML string
+func TextChunkFromYAML(yamlStr string) (TextChunk, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return TextChunk{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTextChunk(data, ctx)
+}
+
+// ThinkingChunk represents A thinking/reasoning content chunk from the LLM response stream.
+
+type ThinkingChunk struct {
+	Kind  string `json:"kind" yaml:"kind"`
+	Value string `json:"value" yaml:"value"`
+}
+
+// LoadThinkingChunk creates a ThinkingChunk from a map[string]interface{}
+func LoadThinkingChunk(data interface{}, ctx *LoadContext) (ThinkingChunk, error) {
+	result := ThinkingChunk{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+		if val, ok := m["value"]; ok && val != nil {
+			result.Value = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ThinkingChunk to map[string]interface{}
+func (obj *ThinkingChunk) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+	result["value"] = obj.Value
+
+	return result
+}
+
+// ToJSON serializes ThinkingChunk to JSON string
+func (obj *ThinkingChunk) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ThinkingChunk to YAML string
+func (obj *ThinkingChunk) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ThinkingChunk from JSON string
+func ThinkingChunkFromJSON(jsonStr string) (ThinkingChunk, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ThinkingChunk{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadThinkingChunk(data, ctx)
+}
+
+// FromYAML creates ThinkingChunk from YAML string
+func ThinkingChunkFromYAML(yamlStr string) (ThinkingChunk, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ThinkingChunk{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadThinkingChunk(data, ctx)
+}
+
+// ToolChunk represents A tool call chunk from the LLM response stream.
+
+type ToolChunk struct {
+	Kind     string   `json:"kind" yaml:"kind"`
+	ToolCall ToolCall `json:"toolCall" yaml:"toolCall"`
+}
+
+// LoadToolChunk creates a ToolChunk from a map[string]interface{}
+func LoadToolChunk(data interface{}, ctx *LoadContext) (ToolChunk, error) {
+	result := ToolChunk{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+		if val, ok := m["toolCall"]; ok && val != nil {
+			if m, ok := val.(map[string]interface{}); ok {
+				loaded, _ := LoadToolCall(m, ctx)
+				result.ToolCall = loaded
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ToolChunk to map[string]interface{}
+func (obj *ToolChunk) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+
+	result["toolCall"] = obj.ToolCall.Save(ctx)
+
+	return result
+}
+
+// ToJSON serializes ToolChunk to JSON string
+func (obj *ToolChunk) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ToolChunk to YAML string
+func (obj *ToolChunk) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ToolChunk from JSON string
+func ToolChunkFromJSON(jsonStr string) (ToolChunk, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ToolChunk{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolChunk(data, ctx)
+}
+
+// FromYAML creates ToolChunk from YAML string
+func ToolChunkFromYAML(yamlStr string) (ToolChunk, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ToolChunk{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolChunk(data, ctx)
+}
+
+// ErrorChunk represents An error chunk from the LLM response stream.
+
+type ErrorChunk struct {
+	Kind    string `json:"kind" yaml:"kind"`
+	Message string `json:"message" yaml:"message"`
+}
+
+// LoadErrorChunk creates a ErrorChunk from a map[string]interface{}
+func LoadErrorChunk(data interface{}, ctx *LoadContext) (ErrorChunk, error) {
+	result := ErrorChunk{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+		if val, ok := m["message"]; ok && val != nil {
+			result.Message = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ErrorChunk to map[string]interface{}
+func (obj *ErrorChunk) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["kind"] = obj.Kind
+	result["message"] = obj.Message
+
+	return result
+}
+
+// ToJSON serializes ErrorChunk to JSON string
+func (obj *ErrorChunk) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ErrorChunk to YAML string
+func (obj *ErrorChunk) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ErrorChunk from JSON string
+func ErrorChunkFromJSON(jsonStr string) (ErrorChunk, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ErrorChunk{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadErrorChunk(data, ctx)
+}
+
+// FromYAML creates ErrorChunk from YAML string
+func ErrorChunkFromYAML(yamlStr string) (ErrorChunk, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ErrorChunk{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadErrorChunk(data, ctx)
+}
diff --git a/runtime/go/prompty/model/stream_chunk_test.go b/runtime/go/prompty/model/stream_chunk_test.go
new file mode 100644
index 00000000..8e719bf5
--- /dev/null
+++ b/runtime/go/prompty/model/stream_chunk_test.go
@@ -0,0 +1,3 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
diff --git a/runtime/go/prompty/model/template_test.go b/runtime/go/prompty/model/template_test.go
index ff9f895a..7bd91083 100644
--- a/runtime/go/prompty/model/template_test.go
+++ b/runtime/go/prompty/model/template_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestTemplateLoadJSON tests loading Template from JSON
diff --git a/runtime/go/prompty/model/text_chunk_test.go b/runtime/go/prompty/model/text_chunk_test.go
new file mode 100644
index 00000000..dec38867
--- /dev/null
+++ b/runtime/go/prompty/model/text_chunk_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestTextChunkLoadJSON tests loading TextChunk from JSON
+func TestTextChunkLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "value": "Hello"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TextChunk: %v", err)
+	}
+	if instance.Value != "Hello" {
+		t.Errorf(`Expected Value to be "Hello", got %v`, instance.Value)
+	}
+}
+
+// TestTextChunkLoadYAML tests loading TextChunk from YAML
+func TestTextChunkLoadYAML(t *testing.T) {
+	yamlData := `
+value: Hello
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TextChunk: %v", err)
+	}
+	if instance.Value != "Hello" {
+		t.Errorf(`Expected Value to be "Hello", got %v`, instance.Value)
+	}
+}
+
+// TestTextChunkRoundtrip tests load -> save -> load produces equivalent data
+func TestTextChunkRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "value": "Hello"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextChunk(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load TextChunk: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadTextChunk(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload TextChunk: %v", err)
+	}
+	if reloaded.Value != "Hello" {
+		t.Errorf(`Expected Value to be "Hello", got %v`, reloaded.Value)
+	}
+}
+
+// TestTextChunkToJSON tests that ToJSON produces valid JSON
+func TestTextChunkToJSON(t *testing.T) {
+	jsonData := `
+{
+  "value": "Hello"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TextChunk: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestTextChunkToYAML tests that ToYAML produces valid YAML
+func TestTextChunkToYAML(t *testing.T) {
+	jsonData := `
+{
+  "value": "Hello"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TextChunk: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/text_part_test.go b/runtime/go/prompty/model/text_part_test.go
new file mode 100644
index 00000000..6b6dad2e
--- /dev/null
+++ b/runtime/go/prompty/model/text_part_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestTextPartLoadJSON tests loading TextPart from JSON
+func TestTextPartLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "value": "Hello, world!"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextPart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TextPart: %v", err)
+	}
+	if instance.Value != "Hello, world!" {
+		t.Errorf(`Expected Value to be "Hello, world!", got %v`, instance.Value)
+	}
+}
+
+// TestTextPartLoadYAML tests loading TextPart from YAML
+func TestTextPartLoadYAML(t *testing.T) {
+	yamlData := `
+value: Hello, world!
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextPart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TextPart: %v", err)
+	}
+	if instance.Value != "Hello, world!" {
+		t.Errorf(`Expected Value to be "Hello, world!", got %v`, instance.Value)
+	}
+}
+
+// TestTextPartRoundtrip tests load -> save -> load produces equivalent data
+func TestTextPartRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "value": "Hello, world!"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextPart(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load TextPart: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadTextPart(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload TextPart: %v", err)
+	}
+	if reloaded.Value != "Hello, world!" {
+		t.Errorf(`Expected Value to be "Hello, world!", got %v`, reloaded.Value)
+	}
+}
+
+// TestTextPartToJSON tests that ToJSON produces valid JSON
+func TestTextPartToJSON(t *testing.T) {
+	jsonData := `
+{
+  "value": "Hello, world!"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextPart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TextPart: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestTextPartToYAML tests that ToYAML produces valid YAML
+func TestTextPartToYAML(t *testing.T) {
+	jsonData := `
+{
+  "value": "Hello, world!"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTextPart(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TextPart: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/thinking_chunk_test.go b/runtime/go/prompty/model/thinking_chunk_test.go
new file mode 100644
index 00000000..4a5b4754
--- /dev/null
+++ b/runtime/go/prompty/model/thinking_chunk_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestThinkingChunkLoadJSON tests loading ThinkingChunk from JSON
+func TestThinkingChunkLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "value": "Let me consider..."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingChunk: %v", err)
+	}
+	if instance.Value != "Let me consider..." {
+		t.Errorf(`Expected Value to be "Let me consider...", got %v`, instance.Value)
+	}
+}
+
+// TestThinkingChunkLoadYAML tests loading ThinkingChunk from YAML
+func TestThinkingChunkLoadYAML(t *testing.T) {
+	yamlData := `
+value: Let me consider...
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingChunk: %v", err)
+	}
+	if instance.Value != "Let me consider..." {
+		t.Errorf(`Expected Value to be "Let me consider...", got %v`, instance.Value)
+	}
+}
+
+// TestThinkingChunkRoundtrip tests load -> save -> load produces equivalent data
+func TestThinkingChunkRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "value": "Let me consider..."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingChunk(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingChunk: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadThinkingChunk(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ThinkingChunk: %v", err)
+	}
+	if reloaded.Value != "Let me consider..." {
+		t.Errorf(`Expected Value to be "Let me consider...", got %v`, reloaded.Value)
+	}
+}
+
+// TestThinkingChunkToJSON tests that ToJSON produces valid JSON
+func TestThinkingChunkToJSON(t *testing.T) {
+	jsonData := `
+{
+  "value": "Let me consider..."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingChunk: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestThinkingChunkToYAML tests that ToYAML produces valid YAML
+func TestThinkingChunkToYAML(t *testing.T) {
+	jsonData := `
+{
+  "value": "Let me consider..."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingChunk: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/thinking_event_payload.go b/runtime/go/prompty/model/thinking_event_payload.go
new file mode 100644
index 00000000..35745e75
--- /dev/null
+++ b/runtime/go/prompty/model/thinking_event_payload.go
@@ -0,0 +1,79 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ThinkingEventPayload represents Payload for "thinking" events — reasoning/chain-of-thought tokens.
+
+type ThinkingEventPayload struct {
+	Token string `json:"token" yaml:"token"`
+}
+
+// LoadThinkingEventPayload creates a ThinkingEventPayload from a map[string]interface{}
+func LoadThinkingEventPayload(data interface{}, ctx *LoadContext) (ThinkingEventPayload, error) {
+	result := ThinkingEventPayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["token"]; ok && val != nil {
+			result.Token = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ThinkingEventPayload to map[string]interface{}
+func (obj *ThinkingEventPayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["token"] = obj.Token
+
+	return result
+}
+
+// ToJSON serializes ThinkingEventPayload to JSON string
+func (obj *ThinkingEventPayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ThinkingEventPayload to YAML string
+func (obj *ThinkingEventPayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ThinkingEventPayload from JSON string
+func ThinkingEventPayloadFromJSON(jsonStr string) (ThinkingEventPayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ThinkingEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadThinkingEventPayload(data, ctx)
+}
+
+// FromYAML creates ThinkingEventPayload from YAML string
+func ThinkingEventPayloadFromYAML(yamlStr string) (ThinkingEventPayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ThinkingEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadThinkingEventPayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/thinking_event_payload_test.go b/runtime/go/prompty/model/thinking_event_payload_test.go
new file mode 100644
index 00000000..68657314
--- /dev/null
+++ b/runtime/go/prompty/model/thinking_event_payload_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestThinkingEventPayloadLoadJSON tests loading ThinkingEventPayload from JSON
+func TestThinkingEventPayloadLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "token": "Let me consider..."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingEventPayload: %v", err)
+	}
+	if instance.Token != "Let me consider..." {
+		t.Errorf(`Expected Token to be "Let me consider...", got %v`, instance.Token)
+	}
+}
+
+// TestThinkingEventPayloadLoadYAML tests loading ThinkingEventPayload from YAML
+func TestThinkingEventPayloadLoadYAML(t *testing.T) {
+	yamlData := `
+token: Let me consider...
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingEventPayload: %v", err)
+	}
+	if instance.Token != "Let me consider..." {
+		t.Errorf(`Expected Token to be "Let me consider...", got %v`, instance.Token)
+	}
+}
+
+// TestThinkingEventPayloadRoundtrip tests load -> save -> load produces equivalent data
+func TestThinkingEventPayloadRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "token": "Let me consider..."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingEventPayload(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingEventPayload: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadThinkingEventPayload(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ThinkingEventPayload: %v", err)
+	}
+	if reloaded.Token != "Let me consider..." {
+		t.Errorf(`Expected Token to be "Let me consider...", got %v`, reloaded.Token)
+	}
+}
+
+// TestThinkingEventPayloadToJSON tests that ToJSON produces valid JSON
+func TestThinkingEventPayloadToJSON(t *testing.T) {
+	jsonData := `
+{
+  "token": "Let me consider..."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingEventPayload: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestThinkingEventPayloadToYAML tests that ToYAML produces valid YAML
+func TestThinkingEventPayloadToYAML(t *testing.T) {
+	jsonData := `
+{
+  "token": "Let me consider..."
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThinkingEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThinkingEventPayload: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/thread_marker.go b/runtime/go/prompty/model/thread_marker.go
new file mode 100644
index 00000000..f49fdc02
--- /dev/null
+++ b/runtime/go/prompty/model/thread_marker.go
@@ -0,0 +1,88 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ThreadMarker represents Positional marker for conversation history insertion during template rendering.
+//
+// During `prepare()`, nonce strings in rendered text are replaced with
+// ThreadMarker objects. The pipeline then replaces them with actual
+// conversation messages from the inputs.
+
+type ThreadMarker struct {
+	Name string `json:"name" yaml:"name"`
+	Kind string `json:"kind" yaml:"kind"`
+}
+
+// LoadThreadMarker creates a ThreadMarker from a map[string]interface{}
+func LoadThreadMarker(data interface{}, ctx *LoadContext) (ThreadMarker, error) {
+	result := ThreadMarker{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["name"]; ok && val != nil {
+			result.Name = val.(string)
+		}
+		if val, ok := m["kind"]; ok && val != nil {
+			result.Kind = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ThreadMarker to map[string]interface{}
+func (obj *ThreadMarker) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["name"] = obj.Name
+	result["kind"] = obj.Kind
+
+	return result
+}
+
+// ToJSON serializes ThreadMarker to JSON string
+func (obj *ThreadMarker) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ThreadMarker to YAML string
+func (obj *ThreadMarker) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ThreadMarker from JSON string
+func ThreadMarkerFromJSON(jsonStr string) (ThreadMarker, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ThreadMarker{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadThreadMarker(data, ctx)
+}
+
+// FromYAML creates ThreadMarker from YAML string
+func ThreadMarkerFromYAML(yamlStr string) (ThreadMarker, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ThreadMarker{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadThreadMarker(data, ctx)
+}
diff --git a/runtime/go/prompty/model/thread_marker_test.go b/runtime/go/prompty/model/thread_marker_test.go
new file mode 100644
index 00000000..0848fa70
--- /dev/null
+++ b/runtime/go/prompty/model/thread_marker_test.go
@@ -0,0 +1,154 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestThreadMarkerLoadJSON tests loading ThreadMarker from JSON
+func TestThreadMarkerLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "name": "thread",
+  "kind": "thread"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThreadMarker(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThreadMarker: %v", err)
+	}
+	if instance.Name != "thread" {
+		t.Errorf(`Expected Name to be "thread", got %v`, instance.Name)
+	}
+	if instance.Kind != "thread" {
+		t.Errorf(`Expected Kind to be "thread", got %v`, instance.Kind)
+	}
+}
+
+// TestThreadMarkerLoadYAML tests loading ThreadMarker from YAML
+func TestThreadMarkerLoadYAML(t *testing.T) {
+	yamlData := `
+name: thread
+kind: thread
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThreadMarker(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThreadMarker: %v", err)
+	}
+	if instance.Name != "thread" {
+		t.Errorf(`Expected Name to be "thread", got %v`, instance.Name)
+	}
+	if instance.Kind != "thread" {
+		t.Errorf(`Expected Kind to be "thread", got %v`, instance.Kind)
+	}
+}
+
+// TestThreadMarkerRoundtrip tests load -> save -> load produces equivalent data
+func TestThreadMarkerRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "name": "thread",
+  "kind": "thread"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThreadMarker(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ThreadMarker: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadThreadMarker(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ThreadMarker: %v", err)
+	}
+	if reloaded.Name != "thread" {
+		t.Errorf(`Expected Name to be "thread", got %v`, reloaded.Name)
+	}
+	if reloaded.Kind != "thread" {
+		t.Errorf(`Expected Kind to be "thread", got %v`, reloaded.Kind)
+	}
+}
+
+// TestThreadMarkerToJSON tests that ToJSON produces valid JSON
+func TestThreadMarkerToJSON(t *testing.T) {
+	jsonData := `
+{
+  "name": "thread",
+  "kind": "thread"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThreadMarker(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThreadMarker: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestThreadMarkerToYAML tests that ToYAML produces valid YAML
+func TestThreadMarkerToYAML(t *testing.T) {
+	jsonData := `
+{
+  "name": "thread",
+  "kind": "thread"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadThreadMarker(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ThreadMarker: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/token_event_payload.go b/runtime/go/prompty/model/token_event_payload.go
new file mode 100644
index 00000000..a569d5f2
--- /dev/null
+++ b/runtime/go/prompty/model/token_event_payload.go
@@ -0,0 +1,79 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// TokenEventPayload represents Payload for "token" events — a single text token streamed from the LLM.
+
+type TokenEventPayload struct {
+	Token string `json:"token" yaml:"token"`
+}
+
+// LoadTokenEventPayload creates a TokenEventPayload from a map[string]interface{}
+func LoadTokenEventPayload(data interface{}, ctx *LoadContext) (TokenEventPayload, error) {
+	result := TokenEventPayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["token"]; ok && val != nil {
+			result.Token = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes TokenEventPayload to map[string]interface{}
+func (obj *TokenEventPayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["token"] = obj.Token
+
+	return result
+}
+
+// ToJSON serializes TokenEventPayload to JSON string
+func (obj *TokenEventPayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes TokenEventPayload to YAML string
+func (obj *TokenEventPayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates TokenEventPayload from JSON string
+func TokenEventPayloadFromJSON(jsonStr string) (TokenEventPayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return TokenEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTokenEventPayload(data, ctx)
+}
+
+// FromYAML creates TokenEventPayload from YAML string
+func TokenEventPayloadFromYAML(yamlStr string) (TokenEventPayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return TokenEventPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTokenEventPayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/token_event_payload_test.go b/runtime/go/prompty/model/token_event_payload_test.go
new file mode 100644
index 00000000..1978b503
--- /dev/null
+++ b/runtime/go/prompty/model/token_event_payload_test.go
@@ -0,0 +1,140 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestTokenEventPayloadLoadJSON tests loading TokenEventPayload from JSON
+func TestTokenEventPayloadLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "token": "Hello"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenEventPayload: %v", err)
+	}
+	if instance.Token != "Hello" {
+		t.Errorf(`Expected Token to be "Hello", got %v`, instance.Token)
+	}
+}
+
+// TestTokenEventPayloadLoadYAML tests loading TokenEventPayload from YAML
+func TestTokenEventPayloadLoadYAML(t *testing.T) {
+	yamlData := `
+token: Hello
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenEventPayload: %v", err)
+	}
+	if instance.Token != "Hello" {
+		t.Errorf(`Expected Token to be "Hello", got %v`, instance.Token)
+	}
+}
+
+// TestTokenEventPayloadRoundtrip tests load -> save -> load produces equivalent data
+func TestTokenEventPayloadRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "token": "Hello"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenEventPayload(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenEventPayload: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadTokenEventPayload(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload TokenEventPayload: %v", err)
+	}
+	if reloaded.Token != "Hello" {
+		t.Errorf(`Expected Token to be "Hello", got %v`, reloaded.Token)
+	}
+}
+
+// TestTokenEventPayloadToJSON tests that ToJSON produces valid JSON
+func TestTokenEventPayloadToJSON(t *testing.T) {
+	jsonData := `
+{
+  "token": "Hello"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenEventPayload: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestTokenEventPayloadToYAML tests that ToYAML produces valid YAML
+func TestTokenEventPayloadToYAML(t *testing.T) {
+	jsonData := `
+{
+  "token": "Hello"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenEventPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenEventPayload: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/token_usage.go b/runtime/go/prompty/model/token_usage.go
new file mode 100644
index 00000000..b6d1277e
--- /dev/null
+++ b/runtime/go/prompty/model/token_usage.go
@@ -0,0 +1,149 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// TokenUsage represents Tracks token consumption for a single LLM call. Provider-specific field
+// names (e.g., OpenAI's `prompt_tokens` vs Anthropic's `input_tokens`)
+// are mapped via `knownAs` augments in the wire directory.
+
+type TokenUsage struct {
+	PromptTokens     *int32 `json:"promptTokens,omitempty" yaml:"promptTokens,omitempty"`
+	CompletionTokens *int32 `json:"completionTokens,omitempty" yaml:"completionTokens,omitempty"`
+	TotalTokens      *int32 `json:"totalTokens,omitempty" yaml:"totalTokens,omitempty"`
+}
+
+// LoadTokenUsage creates a TokenUsage from a map[string]interface{}
+func LoadTokenUsage(data interface{}, ctx *LoadContext) (TokenUsage, error) {
+	result := TokenUsage{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["promptTokens"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.PromptTokens = &v
+		}
+		if val, ok := m["completionTokens"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.CompletionTokens = &v
+		}
+		if val, ok := m["totalTokens"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.TotalTokens = &v
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes TokenUsage to map[string]interface{}
+func (obj *TokenUsage) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	if obj.PromptTokens != nil {
+		result["promptTokens"] = *obj.PromptTokens
+	}
+	if obj.CompletionTokens != nil {
+		result["completionTokens"] = *obj.CompletionTokens
+	}
+	if obj.TotalTokens != nil {
+		result["totalTokens"] = *obj.TotalTokens
+	}
+
+	return result
+}
+
+// ToWire converts to provider-specific wire format.
+func (obj *TokenUsage) ToWire(provider string) map[string]interface{} {
+	data := obj.Save(nil)
+	result := make(map[string]interface{})
+	wireMap := map[string]map[string]string{
+		"promptTokens":     {"openai": "prompt_tokens", "anthropic": "input_tokens"},
+		"completionTokens": {"openai": "completion_tokens", "anthropic": "output_tokens"},
+		"totalTokens":      {"openai": "total_tokens"},
+	}
+	for key, value := range data {
+		if mapping, ok := wireMap[key]; ok {
+			if wireName, ok := mapping[provider]; ok {
+				result[wireName] = value
+			}
+		}
+	}
+	return result
+}
+
+// ToJSON serializes TokenUsage to JSON string
+func (obj *TokenUsage) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes TokenUsage to YAML string
+func (obj *TokenUsage) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates TokenUsage from JSON string
+func TokenUsageFromJSON(jsonStr string) (TokenUsage, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return TokenUsage{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTokenUsage(data, ctx)
+}
+
+// FromYAML creates TokenUsage from YAML string
+func TokenUsageFromYAML(yamlStr string) (TokenUsage, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return TokenUsage{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTokenUsage(data, ctx)
+}
diff --git a/runtime/go/prompty/model/token_usage_test.go b/runtime/go/prompty/model/token_usage_test.go
new file mode 100644
index 00000000..6a512629
--- /dev/null
+++ b/runtime/go/prompty/model/token_usage_test.go
@@ -0,0 +1,168 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestTokenUsageLoadJSON tests loading TokenUsage from JSON
+func TestTokenUsageLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "promptTokens": 150,
+  "completionTokens": 42,
+  "totalTokens": 192
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenUsage(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenUsage: %v", err)
+	}
+	if instance.PromptTokens == nil || *instance.PromptTokens != 150 {
+		t.Errorf(`Expected PromptTokens to be 150, got %v`, instance.PromptTokens)
+	}
+	if instance.CompletionTokens == nil || *instance.CompletionTokens != 42 {
+		t.Errorf(`Expected CompletionTokens to be 42, got %v`, instance.CompletionTokens)
+	}
+	if instance.TotalTokens == nil || *instance.TotalTokens != 192 {
+		t.Errorf(`Expected TotalTokens to be 192, got %v`, instance.TotalTokens)
+	}
+}
+
+// TestTokenUsageLoadYAML tests loading TokenUsage from YAML
+func TestTokenUsageLoadYAML(t *testing.T) {
+	yamlData := `
+promptTokens: 150
+completionTokens: 42
+totalTokens: 192
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenUsage(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenUsage: %v", err)
+	}
+	if instance.PromptTokens == nil || *instance.PromptTokens != 150 {
+		t.Errorf(`Expected PromptTokens to be 150, got %v`, instance.PromptTokens)
+	}
+	if instance.CompletionTokens == nil || *instance.CompletionTokens != 42 {
+		t.Errorf(`Expected CompletionTokens to be 42, got %v`, instance.CompletionTokens)
+	}
+	if instance.TotalTokens == nil || *instance.TotalTokens != 192 {
+		t.Errorf(`Expected TotalTokens to be 192, got %v`, instance.TotalTokens)
+	}
+}
+
+// TestTokenUsageRoundtrip tests load -> save -> load produces equivalent data
+func TestTokenUsageRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "promptTokens": 150,
+  "completionTokens": 42,
+  "totalTokens": 192
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenUsage(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenUsage: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadTokenUsage(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload TokenUsage: %v", err)
+	}
+	if reloaded.PromptTokens == nil || *reloaded.PromptTokens != 150 {
+		t.Errorf(`Expected PromptTokens to be 150, got %v`, reloaded.PromptTokens)
+	}
+	if reloaded.CompletionTokens == nil || *reloaded.CompletionTokens != 42 {
+		t.Errorf(`Expected CompletionTokens to be 42, got %v`, reloaded.CompletionTokens)
+	}
+	if reloaded.TotalTokens == nil || *reloaded.TotalTokens != 192 {
+		t.Errorf(`Expected TotalTokens to be 192, got %v`, reloaded.TotalTokens)
+	}
+}
+
+// TestTokenUsageToJSON tests that ToJSON produces valid JSON
+func TestTokenUsageToJSON(t *testing.T) {
+	jsonData := `
+{
+  "promptTokens": 150,
+  "completionTokens": 42,
+  "totalTokens": 192
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenUsage(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenUsage: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestTokenUsageToYAML tests that ToYAML produces valid YAML
+func TestTokenUsageToYAML(t *testing.T) {
+	jsonData := `
+{
+  "promptTokens": 150,
+  "completionTokens": 42,
+  "totalTokens": 192
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTokenUsage(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TokenUsage: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/tool_call.go b/runtime/go/prompty/model/tool_call.go
new file mode 100644
index 00000000..37325db5
--- /dev/null
+++ b/runtime/go/prompty/model/tool_call.go
@@ -0,0 +1,90 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ToolCall represents A tool call requested by the LLM. Contains the function name and serialized
+// arguments that should be dispatched to the appropriate tool handler.
+
+type ToolCall struct {
+	Id        string `json:"id" yaml:"id"`
+	Name      string `json:"name" yaml:"name"`
+	Arguments string `json:"arguments" yaml:"arguments"`
+}
+
+// LoadToolCall creates a ToolCall from a map[string]interface{}
+func LoadToolCall(data interface{}, ctx *LoadContext) (ToolCall, error) {
+	result := ToolCall{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["id"]; ok && val != nil {
+			result.Id = val.(string)
+		}
+		if val, ok := m["name"]; ok && val != nil {
+			result.Name = val.(string)
+		}
+		if val, ok := m["arguments"]; ok && val != nil {
+			result.Arguments = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ToolCall to map[string]interface{}
+func (obj *ToolCall) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["id"] = obj.Id
+	result["name"] = obj.Name
+	result["arguments"] = obj.Arguments
+
+	return result
+}
+
+// ToJSON serializes ToolCall to JSON string
+func (obj *ToolCall) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ToolCall to YAML string
+func (obj *ToolCall) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ToolCall from JSON string
+func ToolCallFromJSON(jsonStr string) (ToolCall, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ToolCall{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolCall(data, ctx)
+}
+
+// FromYAML creates ToolCall from YAML string
+func ToolCallFromYAML(yamlStr string) (ToolCall, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ToolCall{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolCall(data, ctx)
+}
diff --git a/runtime/go/prompty/model/tool_call_start_payload.go b/runtime/go/prompty/model/tool_call_start_payload.go
new file mode 100644
index 00000000..516ac1e8
--- /dev/null
+++ b/runtime/go/prompty/model/tool_call_start_payload.go
@@ -0,0 +1,84 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ToolCallStartPayload represents Payload for "tool_call_start" events — the LLM has requested a tool call.
+
+type ToolCallStartPayload struct {
+	Name      string `json:"name" yaml:"name"`
+	Arguments string `json:"arguments" yaml:"arguments"`
+}
+
+// LoadToolCallStartPayload creates a ToolCallStartPayload from a map[string]interface{}
+func LoadToolCallStartPayload(data interface{}, ctx *LoadContext) (ToolCallStartPayload, error) {
+	result := ToolCallStartPayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["name"]; ok && val != nil {
+			result.Name = val.(string)
+		}
+		if val, ok := m["arguments"]; ok && val != nil {
+			result.Arguments = val.(string)
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ToolCallStartPayload to map[string]interface{}
+func (obj *ToolCallStartPayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["name"] = obj.Name
+	result["arguments"] = obj.Arguments
+
+	return result
+}
+
+// ToJSON serializes ToolCallStartPayload to JSON string
+func (obj *ToolCallStartPayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ToolCallStartPayload to YAML string
+func (obj *ToolCallStartPayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ToolCallStartPayload from JSON string
+func ToolCallStartPayloadFromJSON(jsonStr string) (ToolCallStartPayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ToolCallStartPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolCallStartPayload(data, ctx)
+}
+
+// FromYAML creates ToolCallStartPayload from YAML string
+func ToolCallStartPayloadFromYAML(yamlStr string) (ToolCallStartPayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ToolCallStartPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolCallStartPayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/tool_call_start_payload_test.go b/runtime/go/prompty/model/tool_call_start_payload_test.go
new file mode 100644
index 00000000..28115bc8
--- /dev/null
+++ b/runtime/go/prompty/model/tool_call_start_payload_test.go
@@ -0,0 +1,154 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestToolCallStartPayloadLoadJSON tests loading ToolCallStartPayload from JSON
+func TestToolCallStartPayloadLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCallStartPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCallStartPayload: %v", err)
+	}
+	if instance.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, instance.Name)
+	}
+	if instance.Arguments != "{\"city\": \"Paris\"}" {
+		t.Errorf(`Expected Arguments to be "{\"city\": \"Paris\"}", got %v`, instance.Arguments)
+	}
+}
+
+// TestToolCallStartPayloadLoadYAML tests loading ToolCallStartPayload from YAML
+func TestToolCallStartPayloadLoadYAML(t *testing.T) {
+	yamlData := `
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCallStartPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCallStartPayload: %v", err)
+	}
+	if instance.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, instance.Name)
+	}
+	if instance.Arguments != "{\"city\": \"Paris\"}" {
+		t.Errorf(`Expected Arguments to be "{\"city\": \"Paris\"}", got %v`, instance.Arguments)
+	}
+}
+
+// TestToolCallStartPayloadRoundtrip tests load -> save -> load produces equivalent data
+func TestToolCallStartPayloadRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCallStartPayload(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCallStartPayload: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadToolCallStartPayload(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ToolCallStartPayload: %v", err)
+	}
+	if reloaded.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, reloaded.Name)
+	}
+	if reloaded.Arguments != "{\"city\": \"Paris\"}" {
+		t.Errorf(`Expected Arguments to be "{\"city\": \"Paris\"}", got %v`, reloaded.Arguments)
+	}
+}
+
+// TestToolCallStartPayloadToJSON tests that ToJSON produces valid JSON
+func TestToolCallStartPayloadToJSON(t *testing.T) {
+	jsonData := `
+{
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCallStartPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCallStartPayload: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestToolCallStartPayloadToYAML tests that ToYAML produces valid YAML
+func TestToolCallStartPayloadToYAML(t *testing.T) {
+	jsonData := `
+{
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCallStartPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCallStartPayload: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/tool_call_test.go b/runtime/go/prompty/model/tool_call_test.go
new file mode 100644
index 00000000..7649eb2d
--- /dev/null
+++ b/runtime/go/prompty/model/tool_call_test.go
@@ -0,0 +1,168 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestToolCallLoadJSON tests loading ToolCall from JSON
+func TestToolCallLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "id": "call_abc123",
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCall(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCall: %v", err)
+	}
+	if instance.Id != "call_abc123" {
+		t.Errorf(`Expected Id to be "call_abc123", got %v`, instance.Id)
+	}
+	if instance.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, instance.Name)
+	}
+	if instance.Arguments != "{\"city\": \"Paris\"}" {
+		t.Errorf(`Expected Arguments to be "{\"city\": \"Paris\"}", got %v`, instance.Arguments)
+	}
+}
+
+// TestToolCallLoadYAML tests loading ToolCall from YAML
+func TestToolCallLoadYAML(t *testing.T) {
+	yamlData := `
+id: call_abc123
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCall(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCall: %v", err)
+	}
+	if instance.Id != "call_abc123" {
+		t.Errorf(`Expected Id to be "call_abc123", got %v`, instance.Id)
+	}
+	if instance.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, instance.Name)
+	}
+	if instance.Arguments != "{\"city\": \"Paris\"}" {
+		t.Errorf(`Expected Arguments to be "{\"city\": \"Paris\"}", got %v`, instance.Arguments)
+	}
+}
+
+// TestToolCallRoundtrip tests load -> save -> load produces equivalent data
+func TestToolCallRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "id": "call_abc123",
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCall(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCall: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadToolCall(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ToolCall: %v", err)
+	}
+	if reloaded.Id != "call_abc123" {
+		t.Errorf(`Expected Id to be "call_abc123", got %v`, reloaded.Id)
+	}
+	if reloaded.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, reloaded.Name)
+	}
+	if reloaded.Arguments != "{\"city\": \"Paris\"}" {
+		t.Errorf(`Expected Arguments to be "{\"city\": \"Paris\"}", got %v`, reloaded.Arguments)
+	}
+}
+
+// TestToolCallToJSON tests that ToJSON produces valid JSON
+func TestToolCallToJSON(t *testing.T) {
+	jsonData := `
+{
+  "id": "call_abc123",
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCall(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCall: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestToolCallToYAML tests that ToYAML produces valid YAML
+func TestToolCallToYAML(t *testing.T) {
+	jsonData := `
+{
+  "id": "call_abc123",
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolCall(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolCall: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/tool_chunk_test.go b/runtime/go/prompty/model/tool_chunk_test.go
new file mode 100644
index 00000000..89bc0f4c
--- /dev/null
+++ b/runtime/go/prompty/model/tool_chunk_test.go
@@ -0,0 +1,153 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestToolChunkLoadJSON tests loading ToolChunk from JSON
+func TestToolChunkLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "toolCall": {
+    "id": "call_abc123",
+    "name": "get_weather",
+    "arguments": "{\"city\": \"Paris\"}"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolChunk: %v", err)
+	}
+	_ = instance // No scalar properties to validate
+}
+
+// TestToolChunkLoadYAML tests loading ToolChunk from YAML
+func TestToolChunkLoadYAML(t *testing.T) {
+	yamlData := `
+toolCall:
+  id: call_abc123
+  name: get_weather
+  arguments: "{\"city\": \"Paris\"}"
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolChunk: %v", err)
+	}
+	_ = instance // No scalar properties to validate
+}
+
+// TestToolChunkRoundtrip tests load -> save -> load produces equivalent data
+func TestToolChunkRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "toolCall": {
+    "id": "call_abc123",
+    "name": "get_weather",
+    "arguments": "{\"city\": \"Paris\"}"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolChunk(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolChunk: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadToolChunk(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ToolChunk: %v", err)
+	}
+	_ = reloaded // No scalar properties to validate
+}
+
+// TestToolChunkToJSON tests that ToJSON produces valid JSON
+func TestToolChunkToJSON(t *testing.T) {
+	jsonData := `
+{
+  "toolCall": {
+    "id": "call_abc123",
+    "name": "get_weather",
+    "arguments": "{\"city\": \"Paris\"}"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolChunk: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestToolChunkToYAML tests that ToYAML produces valid YAML
+func TestToolChunkToYAML(t *testing.T) {
+	jsonData := `
+{
+  "toolCall": {
+    "id": "call_abc123",
+    "name": "get_weather",
+    "arguments": "{\"city\": \"Paris\"}"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolChunk(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolChunk: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/tool_context.go b/runtime/go/prompty/model/tool_context.go
new file mode 100644
index 00000000..fe155968
--- /dev/null
+++ b/runtime/go/prompty/model/tool_context.go
@@ -0,0 +1,104 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ToolContext represents Context passed to tool handlers during agent loop execution. Provides
+// access to the agent configuration, current conversation state, and
+// arbitrary metadata for tool implementations that need broader context.
+
+type ToolContext struct {
+	Messages []Message              `json:"messages" yaml:"messages"`
+	Metadata map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
+}
+
+// LoadToolContext creates a ToolContext from a map[string]interface{}
+func LoadToolContext(data interface{}, ctx *LoadContext) (ToolContext, error) {
+	result := ToolContext{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["messages"]; ok && val != nil {
+			if arr, ok := val.([]interface{}); ok {
+				result.Messages = make([]Message, len(arr))
+				for i, v := range arr {
+					if item, ok := v.(map[string]interface{}); ok {
+						loaded, _ := LoadMessage(item, ctx)
+						result.Messages[i] = loaded
+					}
+				}
+			}
+		}
+		if val, ok := m["metadata"]; ok && val != nil {
+			if m, ok := val.(map[string]interface{}); ok {
+				result.Metadata = m
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ToolContext to map[string]interface{}
+func (obj *ToolContext) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	if obj.Messages != nil {
+		arr := make([]interface{}, len(obj.Messages))
+		for i, item := range obj.Messages {
+			arr[i] = item.Save(ctx)
+		}
+		result["messages"] = arr
+	}
+	if obj.Metadata != nil {
+		result["metadata"] = obj.Metadata
+	}
+
+	return result
+}
+
+// ToJSON serializes ToolContext to JSON string
+func (obj *ToolContext) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ToolContext to YAML string
+func (obj *ToolContext) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ToolContext from JSON string
+func ToolContextFromJSON(jsonStr string) (ToolContext, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ToolContext{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolContext(data, ctx)
+}
+
+// FromYAML creates ToolContext from YAML string
+func ToolContextFromYAML(yamlStr string) (ToolContext, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ToolContext{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolContext(data, ctx)
+}
diff --git a/runtime/go/prompty/model/tool_context_test.go b/runtime/go/prompty/model/tool_context_test.go
new file mode 100644
index 00000000..cd05d2f0
--- /dev/null
+++ b/runtime/go/prompty/model/tool_context_test.go
@@ -0,0 +1,143 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestToolContextLoadJSON tests loading ToolContext from JSON
+func TestToolContextLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "metadata": {
+    "userId": "user-123"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolContext(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolContext: %v", err)
+	}
+	_ = instance // No scalar properties to validate
+}
+
+// TestToolContextLoadYAML tests loading ToolContext from YAML
+func TestToolContextLoadYAML(t *testing.T) {
+	yamlData := `
+metadata:
+  userId: user-123
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolContext(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolContext: %v", err)
+	}
+	_ = instance // No scalar properties to validate
+}
+
+// TestToolContextRoundtrip tests load -> save -> load produces equivalent data
+func TestToolContextRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "metadata": {
+    "userId": "user-123"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolContext(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolContext: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadToolContext(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ToolContext: %v", err)
+	}
+	_ = reloaded // No scalar properties to validate
+}
+
+// TestToolContextToJSON tests that ToJSON produces valid JSON
+func TestToolContextToJSON(t *testing.T) {
+	jsonData := `
+{
+  "metadata": {
+    "userId": "user-123"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolContext(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolContext: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestToolContextToYAML tests that ToYAML produces valid YAML
+func TestToolContextToYAML(t *testing.T) {
+	jsonData := `
+{
+  "metadata": {
+    "userId": "user-123"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolContext(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolContext: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/tool_dispatch_result.go b/runtime/go/prompty/model/tool_dispatch_result.go
new file mode 100644
index 00000000..67b7b48f
--- /dev/null
+++ b/runtime/go/prompty/model/tool_dispatch_result.go
@@ -0,0 +1,95 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ToolDispatchResult represents The result of dispatching a single tool call. Pairs the tool call
+// identifier with the tool's name and result for correlation in the
+// agent loop's message assembly.
+
+type ToolDispatchResult struct {
+	ToolCallId string     `json:"toolCallId" yaml:"toolCallId"`
+	Name       string     `json:"name" yaml:"name"`
+	Result     ToolResult `json:"result" yaml:"result"`
+}
+
+// LoadToolDispatchResult creates a ToolDispatchResult from a map[string]interface{}
+func LoadToolDispatchResult(data interface{}, ctx *LoadContext) (ToolDispatchResult, error) {
+	result := ToolDispatchResult{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["toolCallId"]; ok && val != nil {
+			result.ToolCallId = val.(string)
+		}
+		if val, ok := m["name"]; ok && val != nil {
+			result.Name = val.(string)
+		}
+		if val, ok := m["result"]; ok && val != nil {
+			if m, ok := val.(map[string]interface{}); ok {
+				loaded, _ := LoadToolResult(m, ctx)
+				result.Result = loaded
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ToolDispatchResult to map[string]interface{}
+func (obj *ToolDispatchResult) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["toolCallId"] = obj.ToolCallId
+	result["name"] = obj.Name
+
+	result["result"] = obj.Result.Save(ctx)
+
+	return result
+}
+
+// ToJSON serializes ToolDispatchResult to JSON string
+func (obj *ToolDispatchResult) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ToolDispatchResult to YAML string
+func (obj *ToolDispatchResult) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ToolDispatchResult from JSON string
+func ToolDispatchResultFromJSON(jsonStr string) (ToolDispatchResult, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ToolDispatchResult{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolDispatchResult(data, ctx)
+}
+
+// FromYAML creates ToolDispatchResult from YAML string
+func ToolDispatchResultFromYAML(yamlStr string) (ToolDispatchResult, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ToolDispatchResult{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolDispatchResult(data, ctx)
+}
diff --git a/runtime/go/prompty/model/tool_dispatch_result_test.go b/runtime/go/prompty/model/tool_dispatch_result_test.go
new file mode 100644
index 00000000..5cfda48c
--- /dev/null
+++ b/runtime/go/prompty/model/tool_dispatch_result_test.go
@@ -0,0 +1,190 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestToolDispatchResultLoadJSON tests loading ToolDispatchResult from JSON
+func TestToolDispatchResultLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "toolCallId": "call_abc123",
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolDispatchResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolDispatchResult: %v", err)
+	}
+	if instance.ToolCallId != "call_abc123" {
+		t.Errorf(`Expected ToolCallId to be "call_abc123", got %v`, instance.ToolCallId)
+	}
+	if instance.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, instance.Name)
+	}
+}
+
+// TestToolDispatchResultLoadYAML tests loading ToolDispatchResult from YAML
+func TestToolDispatchResultLoadYAML(t *testing.T) {
+	yamlData := `
+toolCallId: call_abc123
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolDispatchResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolDispatchResult: %v", err)
+	}
+	if instance.ToolCallId != "call_abc123" {
+		t.Errorf(`Expected ToolCallId to be "call_abc123", got %v`, instance.ToolCallId)
+	}
+	if instance.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, instance.Name)
+	}
+}
+
+// TestToolDispatchResultRoundtrip tests load -> save -> load produces equivalent data
+func TestToolDispatchResultRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "toolCallId": "call_abc123",
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolDispatchResult(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolDispatchResult: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadToolDispatchResult(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ToolDispatchResult: %v", err)
+	}
+	if reloaded.ToolCallId != "call_abc123" {
+		t.Errorf(`Expected ToolCallId to be "call_abc123", got %v`, reloaded.ToolCallId)
+	}
+	if reloaded.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, reloaded.Name)
+	}
+}
+
+// TestToolDispatchResultToJSON tests that ToJSON produces valid JSON
+func TestToolDispatchResultToJSON(t *testing.T) {
+	jsonData := `
+{
+  "toolCallId": "call_abc123",
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolDispatchResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolDispatchResult: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestToolDispatchResultToYAML tests that ToYAML produces valid YAML
+func TestToolDispatchResultToYAML(t *testing.T) {
+	jsonData := `
+{
+  "toolCallId": "call_abc123",
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolDispatchResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolDispatchResult: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/tool_result.go b/runtime/go/prompty/model/tool_result.go
new file mode 100644
index 00000000..07571994
--- /dev/null
+++ b/runtime/go/prompty/model/tool_result.go
@@ -0,0 +1,118 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ToolResult represents The result of a tool execution. Contains a list of content parts, enabling
+// rich tool results (text, images, files, audio) rather than just strings.
+//
+// Implementations MUST support conversion from a plain string to a ToolResult
+// containing a single TextPart for backward compatibility.
+
+type ToolResult struct {
+	Parts []interface{} `json:"parts" yaml:"parts"`
+}
+
+// LoadToolResult creates a ToolResult from a map[string]interface{}
+func LoadToolResult(data interface{}, ctx *LoadContext) (ToolResult, error) {
+	result := ToolResult{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["parts"]; ok && val != nil {
+			if arr, ok := val.([]interface{}); ok {
+				result.Parts = make([]interface{}, len(arr))
+				for i, v := range arr {
+					if item, ok := v.(map[string]interface{}); ok {
+						loaded, _ := LoadContentPart(item, ctx)
+						// Polymorphic type - store as interface{}
+						result.Parts[i] = loaded
+					}
+				}
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ToolResult to map[string]interface{}
+func (obj *ToolResult) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	if obj.Parts != nil {
+		arr := make([]interface{}, len(obj.Parts))
+		for i, item := range obj.Parts {
+			// Handle polymorphic type via type switch
+			switch v := item.(type) {
+			case interface {
+				Save(*SaveContext) map[string]interface{}
+			}:
+				arr[i] = v.Save(ctx)
+			default:
+				arr[i] = item
+			}
+		}
+		result["parts"] = arr
+	}
+
+	return result
+}
+
+// ToJSON serializes ToolResult to JSON string
+func (obj *ToolResult) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ToolResult to YAML string
+func (obj *ToolResult) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ToolResult from JSON string
+func ToolResultFromJSON(jsonStr string) (ToolResult, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ToolResult{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolResult(data, ctx)
+}
+
+// FromYAML creates ToolResult from YAML string
+func ToolResultFromYAML(yamlStr string) (ToolResult, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ToolResult{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolResult(data, ctx)
+}
+
+// NewTextToolResult creates a ToolResult with preset field values.
+func NewTextToolResult(value string) ToolResult {
+	return ToolResult{Parts: []interface{}{TextPart{Kind: "text", Value: value}}}
+}
+
+// ToolResultHelpers defines helper methods for ToolResult.
+// Implement these in a separate file (e.g., toolresult_helpers.go).
+type ToolResultHelpers interface {
+	// Text — Concatenate all TextPart values joined by newline
+	Text() string
+}
diff --git a/runtime/go/prompty/model/tool_result_payload.go b/runtime/go/prompty/model/tool_result_payload.go
new file mode 100644
index 00000000..45b9e1e3
--- /dev/null
+++ b/runtime/go/prompty/model/tool_result_payload.go
@@ -0,0 +1,88 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ToolResultPayload represents Payload for "tool_result" events — a tool has returned its result.
+
+type ToolResultPayload struct {
+	Name   string     `json:"name" yaml:"name"`
+	Result ToolResult `json:"result" yaml:"result"`
+}
+
+// LoadToolResultPayload creates a ToolResultPayload from a map[string]interface{}
+func LoadToolResultPayload(data interface{}, ctx *LoadContext) (ToolResultPayload, error) {
+	result := ToolResultPayload{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["name"]; ok && val != nil {
+			result.Name = val.(string)
+		}
+		if val, ok := m["result"]; ok && val != nil {
+			if m, ok := val.(map[string]interface{}); ok {
+				loaded, _ := LoadToolResult(m, ctx)
+				result.Result = loaded
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes ToolResultPayload to map[string]interface{}
+func (obj *ToolResultPayload) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	result["name"] = obj.Name
+
+	result["result"] = obj.Result.Save(ctx)
+
+	return result
+}
+
+// ToJSON serializes ToolResultPayload to JSON string
+func (obj *ToolResultPayload) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes ToolResultPayload to YAML string
+func (obj *ToolResultPayload) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates ToolResultPayload from JSON string
+func ToolResultPayloadFromJSON(jsonStr string) (ToolResultPayload, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return ToolResultPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolResultPayload(data, ctx)
+}
+
+// FromYAML creates ToolResultPayload from YAML string
+func ToolResultPayloadFromYAML(yamlStr string) (ToolResultPayload, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return ToolResultPayload{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadToolResultPayload(data, ctx)
+}
diff --git a/runtime/go/prompty/model/tool_result_payload_test.go b/runtime/go/prompty/model/tool_result_payload_test.go
new file mode 100644
index 00000000..86ab959d
--- /dev/null
+++ b/runtime/go/prompty/model/tool_result_payload_test.go
@@ -0,0 +1,176 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestToolResultPayloadLoadJSON tests loading ToolResultPayload from JSON
+func TestToolResultPayloadLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResultPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResultPayload: %v", err)
+	}
+	if instance.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, instance.Name)
+	}
+}
+
+// TestToolResultPayloadLoadYAML tests loading ToolResultPayload from YAML
+func TestToolResultPayloadLoadYAML(t *testing.T) {
+	yamlData := `
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResultPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResultPayload: %v", err)
+	}
+	if instance.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, instance.Name)
+	}
+}
+
+// TestToolResultPayloadRoundtrip tests load -> save -> load produces equivalent data
+func TestToolResultPayloadRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResultPayload(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResultPayload: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadToolResultPayload(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ToolResultPayload: %v", err)
+	}
+	if reloaded.Name != "get_weather" {
+		t.Errorf(`Expected Name to be "get_weather", got %v`, reloaded.Name)
+	}
+}
+
+// TestToolResultPayloadToJSON tests that ToJSON produces valid JSON
+func TestToolResultPayloadToJSON(t *testing.T) {
+	jsonData := `
+{
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResultPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResultPayload: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestToolResultPayloadToYAML tests that ToYAML produces valid YAML
+func TestToolResultPayloadToYAML(t *testing.T) {
+	jsonData := `
+{
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResultPayload(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResultPayload: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/tool_result_test.go b/runtime/go/prompty/model/tool_result_test.go
new file mode 100644
index 00000000..cd2c39af
--- /dev/null
+++ b/runtime/go/prompty/model/tool_result_test.go
@@ -0,0 +1,156 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestToolResultLoadJSON tests loading ToolResult from JSON
+func TestToolResultLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "parts": [
+    {
+      "kind": "text",
+      "value": "72°F and sunny"
+    }
+  ]
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResult: %v", err)
+	}
+	_ = instance // No scalar properties to validate
+}
+
+// TestToolResultLoadYAML tests loading ToolResult from YAML
+func TestToolResultLoadYAML(t *testing.T) {
+	yamlData := `
+parts:
+  - kind: text
+    value: 72°F and sunny
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResult: %v", err)
+	}
+	_ = instance // No scalar properties to validate
+}
+
+// TestToolResultRoundtrip tests load -> save -> load produces equivalent data
+func TestToolResultRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "parts": [
+    {
+      "kind": "text",
+      "value": "72°F and sunny"
+    }
+  ]
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResult(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResult: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadToolResult(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload ToolResult: %v", err)
+	}
+	_ = reloaded // No scalar properties to validate
+}
+
+// TestToolResultToJSON tests that ToJSON produces valid JSON
+func TestToolResultToJSON(t *testing.T) {
+	jsonData := `
+{
+  "parts": [
+    {
+      "kind": "text",
+      "value": "72°F and sunny"
+    }
+  ]
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResult: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestToolResultToYAML tests that ToYAML produces valid YAML
+func TestToolResultToYAML(t *testing.T) {
+	jsonData := `
+{
+  "parts": [
+    {
+      "kind": "text",
+      "value": "72°F and sunny"
+    }
+  ]
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadToolResult(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load ToolResult: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/go/prompty/model/tool_test.go b/runtime/go/prompty/model/tool_test.go
index cfe11413..e3e3fba4 100644
--- a/runtime/go/prompty/model/tool_test.go
+++ b/runtime/go/prompty/model/tool_test.go
@@ -8,7 +8,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 
-	"github.com/microsoft/agentschema-go/prompty"
+	"prompty/model"
 )
 
 // TestToolLoadJSON tests loading Tool from JSON
diff --git a/runtime/go/prompty/model/turn_options.go b/runtime/go/prompty/model/turn_options.go
new file mode 100644
index 00000000..7497a74e
--- /dev/null
+++ b/runtime/go/prompty/model/turn_options.go
@@ -0,0 +1,177 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty
+
+import (
+	"encoding/json"
+
+	"gopkg.in/yaml.v3"
+)
+
+// TurnOptions represents Configuration for the agent loop's turn() function. Controls iteration
+// limits, retry policy, context management, and execution behavior.
+//
+// Runtimes accept these as either a TurnOptions object or individual
+// keyword/named parameters — the TypeSpec model defines the canonical
+// field set.
+
+type TurnOptions struct {
+	MaxIterations     *int32            `json:"maxIterations,omitempty" yaml:"maxIterations,omitempty"`
+	MaxLlmRetries     *int32            `json:"maxLlmRetries,omitempty" yaml:"maxLlmRetries,omitempty"`
+	ContextBudget     *int32            `json:"contextBudget,omitempty" yaml:"contextBudget,omitempty"`
+	ParallelToolCalls *bool             `json:"parallelToolCalls,omitempty" yaml:"parallelToolCalls,omitempty"`
+	Raw               *bool             `json:"raw,omitempty" yaml:"raw,omitempty"`
+	Turn              *int32            `json:"turn,omitempty" yaml:"turn,omitempty"`
+	Compaction        *CompactionConfig `json:"compaction,omitempty" yaml:"compaction,omitempty"`
+}
+
+// LoadTurnOptions creates a TurnOptions from a map[string]interface{}
+func LoadTurnOptions(data interface{}, ctx *LoadContext) (TurnOptions, error) {
+	result := TurnOptions{}
+
+	// Load from map
+	if m, ok := data.(map[string]interface{}); ok {
+		if val, ok := m["maxIterations"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.MaxIterations = &v
+		}
+		if val, ok := m["maxLlmRetries"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.MaxLlmRetries = &v
+		}
+		if val, ok := m["contextBudget"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.ContextBudget = &v
+		}
+		if val, ok := m["parallelToolCalls"]; ok && val != nil {
+			v := val.(bool)
+			result.ParallelToolCalls = &v
+		}
+		if val, ok := m["raw"]; ok && val != nil {
+			v := val.(bool)
+			result.Raw = &v
+		}
+		if val, ok := m["turn"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip
+			var v int32
+			switch n := val.(type) {
+			case int:
+				v = int32(n)
+			case int32:
+				v = int32(n)
+			case int64:
+				v = int32(n)
+			case float64:
+				v = int32(n)
+			}
+			result.Turn = &v
+		}
+		if val, ok := m["compaction"]; ok && val != nil {
+			if m, ok := val.(map[string]interface{}); ok {
+				loaded, _ := LoadCompactionConfig(m, ctx)
+				result.Compaction = &loaded
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// Save serializes TurnOptions to map[string]interface{}
+func (obj *TurnOptions) Save(ctx *SaveContext) map[string]interface{} {
+	result := make(map[string]interface{})
+	if obj.MaxIterations != nil {
+		result["maxIterations"] = *obj.MaxIterations
+	}
+	if obj.MaxLlmRetries != nil {
+		result["maxLlmRetries"] = *obj.MaxLlmRetries
+	}
+	if obj.ContextBudget != nil {
+		result["contextBudget"] = *obj.ContextBudget
+	}
+	if obj.ParallelToolCalls != nil {
+		result["parallelToolCalls"] = *obj.ParallelToolCalls
+	}
+	if obj.Raw != nil {
+		result["raw"] = *obj.Raw
+	}
+	if obj.Turn != nil {
+		result["turn"] = *obj.Turn
+	}
+	if obj.Compaction != nil {
+		result["compaction"] = obj.Compaction.Save(ctx)
+	}
+
+	return result
+}
+
+// ToJSON serializes TurnOptions to JSON string
+func (obj *TurnOptions) ToJSON() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// ToYAML serializes TurnOptions to YAML string
+func (obj *TurnOptions) ToYAML() (string, error) {
+	ctx := NewSaveContext()
+	data := obj.Save(ctx)
+	bytes, err := yaml.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+// FromJSON creates TurnOptions from JSON string
+func TurnOptionsFromJSON(jsonStr string) (TurnOptions, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
+		return TurnOptions{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTurnOptions(data, ctx)
+}
+
+// FromYAML creates TurnOptions from YAML string
+func TurnOptionsFromYAML(yamlStr string) (TurnOptions, error) {
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
+		return TurnOptions{}, err
+	}
+	ctx := NewLoadContext()
+	return LoadTurnOptions(data, ctx)
+}
diff --git a/runtime/go/prompty/model/turn_options_test.go b/runtime/go/prompty/model/turn_options_test.go
new file mode 100644
index 00000000..2bae1e0d
--- /dev/null
+++ b/runtime/go/prompty/model/turn_options_test.go
@@ -0,0 +1,224 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+package prompty_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+
+	"prompty/model"
+)
+
+// TestTurnOptionsLoadJSON tests loading TurnOptions from JSON
+func TestTurnOptionsLoadJSON(t *testing.T) {
+	jsonData := `
+{
+  "maxIterations": 10,
+  "maxLlmRetries": 3,
+  "contextBudget": 100000,
+  "parallelToolCalls": true,
+  "raw": false,
+  "turn": 1,
+  "compaction": {
+    "strategy": "summarize"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTurnOptions(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TurnOptions: %v", err)
+	}
+	if instance.MaxIterations == nil || *instance.MaxIterations != 10 {
+		t.Errorf(`Expected MaxIterations to be 10, got %v`, instance.MaxIterations)
+	}
+	if instance.MaxLlmRetries == nil || *instance.MaxLlmRetries != 3 {
+		t.Errorf(`Expected MaxLlmRetries to be 3, got %v`, instance.MaxLlmRetries)
+	}
+	if instance.ContextBudget == nil || *instance.ContextBudget != 100000 {
+		t.Errorf(`Expected ContextBudget to be 100000, got %v`, instance.ContextBudget)
+	}
+	if instance.ParallelToolCalls == nil || *instance.ParallelToolCalls != true {
+		t.Errorf(`Expected ParallelToolCalls to be true, got %v`, instance.ParallelToolCalls)
+	}
+	if instance.Raw == nil || *instance.Raw != false {
+		t.Errorf(`Expected Raw to be false, got %v`, instance.Raw)
+	}
+	if instance.Turn == nil || *instance.Turn != 1 {
+		t.Errorf(`Expected Turn to be 1, got %v`, instance.Turn)
+	}
+}
+
+// TestTurnOptionsLoadYAML tests loading TurnOptions from YAML
+func TestTurnOptionsLoadYAML(t *testing.T) {
+	yamlData := `
+maxIterations: 10
+maxLlmRetries: 3
+contextBudget: 100000
+parallelToolCalls: true
+raw: false
+turn: 1
+compaction:
+  strategy: summarize
+
+`
+	var data map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
+		t.Fatalf("Failed to parse YAML: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTurnOptions(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TurnOptions: %v", err)
+	}
+	if instance.MaxIterations == nil || *instance.MaxIterations != 10 {
+		t.Errorf(`Expected MaxIterations to be 10, got %v`, instance.MaxIterations)
+	}
+	if instance.MaxLlmRetries == nil || *instance.MaxLlmRetries != 3 {
+		t.Errorf(`Expected MaxLlmRetries to be 3, got %v`, instance.MaxLlmRetries)
+	}
+	if instance.ContextBudget == nil || *instance.ContextBudget != 100000 {
+		t.Errorf(`Expected ContextBudget to be 100000, got %v`, instance.ContextBudget)
+	}
+	if instance.ParallelToolCalls == nil || *instance.ParallelToolCalls != true {
+		t.Errorf(`Expected ParallelToolCalls to be true, got %v`, instance.ParallelToolCalls)
+	}
+	if instance.Raw == nil || *instance.Raw != false {
+		t.Errorf(`Expected Raw to be false, got %v`, instance.Raw)
+	}
+	if instance.Turn == nil || *instance.Turn != 1 {
+		t.Errorf(`Expected Turn to be 1, got %v`, instance.Turn)
+	}
+}
+
+// TestTurnOptionsRoundtrip tests load -> save -> load produces equivalent data
+func TestTurnOptionsRoundtrip(t *testing.T) {
+	jsonData := `
+{
+  "maxIterations": 10,
+  "maxLlmRetries": 3,
+  "contextBudget": 100000,
+  "parallelToolCalls": true,
+  "raw": false,
+  "turn": 1,
+  "compaction": {
+    "strategy": "summarize"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	loadCtx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTurnOptions(data, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to load TurnOptions: %v", err)
+	}
+	saveCtx := prompty.NewSaveContext()
+	savedData := instance.Save(saveCtx)
+
+	reloaded, err := prompty.LoadTurnOptions(savedData, loadCtx)
+	if err != nil {
+		t.Fatalf("Failed to reload TurnOptions: %v", err)
+	}
+	if reloaded.MaxIterations == nil || *reloaded.MaxIterations != 10 {
+		t.Errorf(`Expected MaxIterations to be 10, got %v`, reloaded.MaxIterations)
+	}
+	if reloaded.MaxLlmRetries == nil || *reloaded.MaxLlmRetries != 3 {
+		t.Errorf(`Expected MaxLlmRetries to be 3, got %v`, reloaded.MaxLlmRetries)
+	}
+	if reloaded.ContextBudget == nil || *reloaded.ContextBudget != 100000 {
+		t.Errorf(`Expected ContextBudget to be 100000, got %v`, reloaded.ContextBudget)
+	}
+	if reloaded.ParallelToolCalls == nil || *reloaded.ParallelToolCalls != true {
+		t.Errorf(`Expected ParallelToolCalls to be true, got %v`, reloaded.ParallelToolCalls)
+	}
+	if reloaded.Raw == nil || *reloaded.Raw != false {
+		t.Errorf(`Expected Raw to be false, got %v`, reloaded.Raw)
+	}
+	if reloaded.Turn == nil || *reloaded.Turn != 1 {
+		t.Errorf(`Expected Turn to be 1, got %v`, reloaded.Turn)
+	}
+}
+
+// TestTurnOptionsToJSON tests that ToJSON produces valid JSON
+func TestTurnOptionsToJSON(t *testing.T) {
+	jsonData := `
+{
+  "maxIterations": 10,
+  "maxLlmRetries": 3,
+  "contextBudget": 100000,
+  "parallelToolCalls": true,
+  "raw": false,
+  "turn": 1,
+  "compaction": {
+    "strategy": "summarize"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTurnOptions(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TurnOptions: %v", err)
+	}
+	jsonOutput, err := instance.ToJSON()
+	if err != nil {
+		t.Fatalf("Failed to convert to JSON: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated JSON: %v", err)
+	}
+}
+
+// TestTurnOptionsToYAML tests that ToYAML produces valid YAML
+func TestTurnOptionsToYAML(t *testing.T) {
+	jsonData := `
+{
+  "maxIterations": 10,
+  "maxLlmRetries": 3,
+  "contextBudget": 100000,
+  "parallelToolCalls": true,
+  "raw": false,
+  "turn": 1,
+  "compaction": {
+    "strategy": "summarize"
+  }
+}
+`
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
+		t.Fatalf("Failed to parse JSON: %v", err)
+	}
+
+	ctx := prompty.NewLoadContext()
+	instance, err := prompty.LoadTurnOptions(data, ctx)
+	if err != nil {
+		t.Fatalf("Failed to load TurnOptions: %v", err)
+	}
+	yamlOutput, err := instance.ToYAML()
+	if err != nil {
+		t.Fatalf("Failed to convert to YAML: %v", err)
+	}
+
+	var parsed map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
+		t.Fatalf("Failed to parse generated YAML: %v", err)
+	}
+}
diff --git a/runtime/python/prompty/.venv_new/Scripts/Activate.ps1 b/runtime/python/prompty/.venv_new/Scripts/Activate.ps1
new file mode 100644
index 00000000..dbbf985c
--- /dev/null
+++ b/runtime/python/prompty/.venv_new/Scripts/Activate.ps1
@@ -0,0 +1,502 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"
+
+# SIG # Begin signature block
+# MIIvIwYJKoZIhvcNAQcCoIIvFDCCLxACAQExDzANBglghkgBZQMEAgEFADB5Bgor
+# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG
+# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCBnL745ElCYk8vk
+# dBtMuQhLeWJ3ZGfzKW4DHCYzAn+QB6CCE8MwggWQMIIDeKADAgECAhAFmxtXno4h
+# MuI5B72nd3VcMA0GCSqGSIb3DQEBDAUAMGIxCzAJBgNVBAYTAlVTMRUwEwYDVQQK
+# EwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAfBgNV
+# BAMTGERpZ2lDZXJ0IFRydXN0ZWQgUm9vdCBHNDAeFw0xMzA4MDExMjAwMDBaFw0z
+# ODAxMTUxMjAwMDBaMGIxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJ
+# bmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAfBgNVBAMTGERpZ2lDZXJ0
+# IFRydXN0ZWQgUm9vdCBHNDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
+# AL/mkHNo3rvkXUo8MCIwaTPswqclLskhPfKK2FnC4SmnPVirdprNrnsbhA3EMB/z
+# G6Q4FutWxpdtHauyefLKEdLkX9YFPFIPUh/GnhWlfr6fqVcWWVVyr2iTcMKyunWZ
+# anMylNEQRBAu34LzB4TmdDttceItDBvuINXJIB1jKS3O7F5OyJP4IWGbNOsFxl7s
+# Wxq868nPzaw0QF+xembud8hIqGZXV59UWI4MK7dPpzDZVu7Ke13jrclPXuU15zHL
+# 2pNe3I6PgNq2kZhAkHnDeMe2scS1ahg4AxCN2NQ3pC4FfYj1gj4QkXCrVYJBMtfb
+# BHMqbpEBfCFM1LyuGwN1XXhm2ToxRJozQL8I11pJpMLmqaBn3aQnvKFPObURWBf3
+# JFxGj2T3wWmIdph2PVldQnaHiZdpekjw4KISG2aadMreSx7nDmOu5tTvkpI6nj3c
+# AORFJYm2mkQZK37AlLTSYW3rM9nF30sEAMx9HJXDj/chsrIRt7t/8tWMcCxBYKqx
+# YxhElRp2Yn72gLD76GSmM9GJB+G9t+ZDpBi4pncB4Q+UDCEdslQpJYls5Q5SUUd0
+# viastkF13nqsX40/ybzTQRESW+UQUOsxxcpyFiIJ33xMdT9j7CFfxCBRa2+xq4aL
+# T8LWRV+dIPyhHsXAj6KxfgommfXkaS+YHS312amyHeUbAgMBAAGjQjBAMA8GA1Ud
+# EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBTs1+OC0nFdZEzf
+# Lmc/57qYrhwPTzANBgkqhkiG9w0BAQwFAAOCAgEAu2HZfalsvhfEkRvDoaIAjeNk
+# aA9Wz3eucPn9mkqZucl4XAwMX+TmFClWCzZJXURj4K2clhhmGyMNPXnpbWvWVPjS
+# PMFDQK4dUPVS/JA7u5iZaWvHwaeoaKQn3J35J64whbn2Z006Po9ZOSJTROvIXQPK
+# 7VB6fWIhCoDIc2bRoAVgX+iltKevqPdtNZx8WorWojiZ83iL9E3SIAveBO6Mm0eB
+# cg3AFDLvMFkuruBx8lbkapdvklBtlo1oepqyNhR6BvIkuQkRUNcIsbiJeoQjYUIp
+# 5aPNoiBB19GcZNnqJqGLFNdMGbJQQXE9P01wI4YMStyB0swylIQNCAmXHE/A7msg
+# dDDS4Dk0EIUhFQEI6FUy3nFJ2SgXUE3mvk3RdazQyvtBuEOlqtPDBURPLDab4vri
+# RbgjU2wGb2dVf0a1TD9uKFp5JtKkqGKX0h7i7UqLvBv9R0oN32dmfrJbQdA75PQ7
+# 9ARj6e/CVABRoIoqyc54zNXqhwQYs86vSYiv85KZtrPmYQ/ShQDnUBrkG5WdGaG5
+# nLGbsQAe79APT0JsyQq87kP6OnGlyE0mpTX9iV28hWIdMtKgK1TtmlfB2/oQzxm3
+# i0objwG2J5VT6LaJbVu8aNQj6ItRolb58KaAoNYes7wPD1N1KarqE3fk3oyBIa0H
+# EEcRrYc9B9F1vM/zZn4wggawMIIEmKADAgECAhAIrUCyYNKcTJ9ezam9k67ZMA0G
+# CSqGSIb3DQEBDAUAMGIxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJ
+# bmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAfBgNVBAMTGERpZ2lDZXJ0
+# IFRydXN0ZWQgUm9vdCBHNDAeFw0yMTA0MjkwMDAwMDBaFw0zNjA0MjgyMzU5NTla
+# MGkxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwgSW5jLjFBMD8GA1UE
+# AxM4RGlnaUNlcnQgVHJ1c3RlZCBHNCBDb2RlIFNpZ25pbmcgUlNBNDA5NiBTSEEz
+# ODQgMjAyMSBDQTEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDVtC9C
+# 0CiteLdd1TlZG7GIQvUzjOs9gZdwxbvEhSYwn6SOaNhc9es0JAfhS0/TeEP0F9ce
+# 2vnS1WcaUk8OoVf8iJnBkcyBAz5NcCRks43iCH00fUyAVxJrQ5qZ8sU7H/Lvy0da
+# E6ZMswEgJfMQ04uy+wjwiuCdCcBlp/qYgEk1hz1RGeiQIXhFLqGfLOEYwhrMxe6T
+# SXBCMo/7xuoc82VokaJNTIIRSFJo3hC9FFdd6BgTZcV/sk+FLEikVoQ11vkunKoA
+# FdE3/hoGlMJ8yOobMubKwvSnowMOdKWvObarYBLj6Na59zHh3K3kGKDYwSNHR7Oh
+# D26jq22YBoMbt2pnLdK9RBqSEIGPsDsJ18ebMlrC/2pgVItJwZPt4bRc4G/rJvmM
+# 1bL5OBDm6s6R9b7T+2+TYTRcvJNFKIM2KmYoX7BzzosmJQayg9Rc9hUZTO1i4F4z
+# 8ujo7AqnsAMrkbI2eb73rQgedaZlzLvjSFDzd5Ea/ttQokbIYViY9XwCFjyDKK05
+# huzUtw1T0PhH5nUwjewwk3YUpltLXXRhTT8SkXbev1jLchApQfDVxW0mdmgRQRNY
+# mtwmKwH0iU1Z23jPgUo+QEdfyYFQc4UQIyFZYIpkVMHMIRroOBl8ZhzNeDhFMJlP
+# /2NPTLuqDQhTQXxYPUez+rbsjDIJAsxsPAxWEQIDAQABo4IBWTCCAVUwEgYDVR0T
+# AQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUaDfg67Y7+F8Rhvv+YXsIiGX0TkIwHwYD
+# VR0jBBgwFoAU7NfjgtJxXWRM3y5nP+e6mK4cD08wDgYDVR0PAQH/BAQDAgGGMBMG
+# A1UdJQQMMAoGCCsGAQUFBwMDMHcGCCsGAQUFBwEBBGswaTAkBggrBgEFBQcwAYYY
+# aHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEEGCCsGAQUFBzAChjVodHRwOi8vY2Fj
+# ZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRUcnVzdGVkUm9vdEc0LmNydDBDBgNV
+# HR8EPDA6MDigNqA0hjJodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vRGlnaUNlcnRU
+# cnVzdGVkUm9vdEc0LmNybDAcBgNVHSAEFTATMAcGBWeBDAEDMAgGBmeBDAEEATAN
+# BgkqhkiG9w0BAQwFAAOCAgEAOiNEPY0Idu6PvDqZ01bgAhql+Eg08yy25nRm95Ry
+# sQDKr2wwJxMSnpBEn0v9nqN8JtU3vDpdSG2V1T9J9Ce7FoFFUP2cvbaF4HZ+N3HL
+# IvdaqpDP9ZNq4+sg0dVQeYiaiorBtr2hSBh+3NiAGhEZGM1hmYFW9snjdufE5Btf
+# Q/g+lP92OT2e1JnPSt0o618moZVYSNUa/tcnP/2Q0XaG3RywYFzzDaju4ImhvTnh
+# OE7abrs2nfvlIVNaw8rpavGiPttDuDPITzgUkpn13c5UbdldAhQfQDN8A+KVssIh
+# dXNSy0bYxDQcoqVLjc1vdjcshT8azibpGL6QB7BDf5WIIIJw8MzK7/0pNVwfiThV
+# 9zeKiwmhywvpMRr/LhlcOXHhvpynCgbWJme3kuZOX956rEnPLqR0kq3bPKSchh/j
+# wVYbKyP/j7XqiHtwa+aguv06P0WmxOgWkVKLQcBIhEuWTatEQOON8BUozu3xGFYH
+# Ki8QxAwIZDwzj64ojDzLj4gLDb879M4ee47vtevLt/B3E+bnKD+sEq6lLyJsQfmC
+# XBVmzGwOysWGw/YmMwwHS6DTBwJqakAwSEs0qFEgu60bhQjiWQ1tygVQK+pKHJ6l
+# /aCnHwZ05/LWUpD9r4VIIflXO7ScA+2GRfS0YW6/aOImYIbqyK+p/pQd52MbOoZW
+# eE4wggd3MIIFX6ADAgECAhAHHxQbizANJfMU6yMM0NHdMA0GCSqGSIb3DQEBCwUA
+# MGkxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwgSW5jLjFBMD8GA1UE
+# AxM4RGlnaUNlcnQgVHJ1c3RlZCBHNCBDb2RlIFNpZ25pbmcgUlNBNDA5NiBTSEEz
+# ODQgMjAyMSBDQTEwHhcNMjIwMTE3MDAwMDAwWhcNMjUwMTE1MjM1OTU5WjB8MQsw
+# CQYDVQQGEwJVUzEPMA0GA1UECBMGT3JlZ29uMRIwEAYDVQQHEwlCZWF2ZXJ0b24x
+# IzAhBgNVBAoTGlB5dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9uMSMwIQYDVQQDExpQ
+# eXRob24gU29mdHdhcmUgRm91bmRhdGlvbjCCAiIwDQYJKoZIhvcNAQEBBQADggIP
+# ADCCAgoCggIBAKgc0BTT+iKbtK6f2mr9pNMUTcAJxKdsuOiSYgDFfwhjQy89koM7
+# uP+QV/gwx8MzEt3c9tLJvDccVWQ8H7mVsk/K+X+IufBLCgUi0GGAZUegEAeRlSXx
+# xhYScr818ma8EvGIZdiSOhqjYc4KnfgfIS4RLtZSrDFG2tN16yS8skFa3IHyvWdb
+# D9PvZ4iYNAS4pjYDRjT/9uzPZ4Pan+53xZIcDgjiTwOh8VGuppxcia6a7xCyKoOA
+# GjvCyQsj5223v1/Ig7Dp9mGI+nh1E3IwmyTIIuVHyK6Lqu352diDY+iCMpk9Zanm
+# SjmB+GMVs+H/gOiofjjtf6oz0ki3rb7sQ8fTnonIL9dyGTJ0ZFYKeb6BLA66d2GA
+# LwxZhLe5WH4Np9HcyXHACkppsE6ynYjTOd7+jN1PRJahN1oERzTzEiV6nCO1M3U1
+# HbPTGyq52IMFSBM2/07WTJSbOeXjvYR7aUxK9/ZkJiacl2iZI7IWe7JKhHohqKuc
+# eQNyOzxTakLcRkzynvIrk33R9YVqtB4L6wtFxhUjvDnQg16xot2KVPdfyPAWd81w
+# tZADmrUtsZ9qG79x1hBdyOl4vUtVPECuyhCxaw+faVjumapPUnwo8ygflJJ74J+B
+# Yxf6UuD7m8yzsfXWkdv52DjL74TxzuFTLHPyARWCSCAbzn3ZIly+qIqDAgMBAAGj
+# ggIGMIICAjAfBgNVHSMEGDAWgBRoN+Drtjv4XxGG+/5hewiIZfROQjAdBgNVHQ4E
+# FgQUt/1Teh2XDuUj2WW3siYWJgkZHA8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQM
+# MAoGCCsGAQUFBwMDMIG1BgNVHR8Ega0wgaowU6BRoE+GTWh0dHA6Ly9jcmwzLmRp
+# Z2ljZXJ0LmNvbS9EaWdpQ2VydFRydXN0ZWRHNENvZGVTaWduaW5nUlNBNDA5NlNI
+# QTM4NDIwMjFDQTEuY3JsMFOgUaBPhk1odHRwOi8vY3JsNC5kaWdpY2VydC5jb20v
+# RGlnaUNlcnRUcnVzdGVkRzRDb2RlU2lnbmluZ1JTQTQwOTZTSEEzODQyMDIxQ0Ex
+# LmNybDA+BgNVHSAENzA1MDMGBmeBDAEEATApMCcGCCsGAQUFBwIBFhtodHRwOi8v
+# d3d3LmRpZ2ljZXJ0LmNvbS9DUFMwgZQGCCsGAQUFBwEBBIGHMIGEMCQGCCsGAQUF
+# BzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wXAYIKwYBBQUHMAKGUGh0dHA6
+# Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydFRydXN0ZWRHNENvZGVTaWdu
+# aW5nUlNBNDA5NlNIQTM4NDIwMjFDQTEuY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZI
+# hvcNAQELBQADggIBABxv4AeV/5ltkELHSC63fXAFYS5tadcWTiNc2rskrNLrfH1N
+# s0vgSZFoQxYBFKI159E8oQQ1SKbTEubZ/B9kmHPhprHya08+VVzxC88pOEvz68nA
+# 82oEM09584aILqYmj8Pj7h/kmZNzuEL7WiwFa/U1hX+XiWfLIJQsAHBla0i7QRF2
+# de8/VSF0XXFa2kBQ6aiTsiLyKPNbaNtbcucaUdn6vVUS5izWOXM95BSkFSKdE45O
+# q3FForNJXjBvSCpwcP36WklaHL+aHu1upIhCTUkzTHMh8b86WmjRUqbrnvdyR2yd
+# I5l1OqcMBjkpPpIV6wcc+KY/RH2xvVuuoHjlUjwq2bHiNoX+W1scCpnA8YTs2d50
+# jDHUgwUo+ciwpffH0Riq132NFmrH3r67VaN3TuBxjI8SIZM58WEDkbeoriDk3hxU
+# 8ZWV7b8AW6oyVBGfM06UgkfMb58h+tJPrFx8VI/WLq1dTqMfZOm5cuclMnUHs2uq
+# rRNtnV8UfidPBL4ZHkTcClQbCoz0UbLhkiDvIS00Dn+BBcxw/TKqVL4Oaz3bkMSs
+# M46LciTeucHY9ExRVt3zy7i149sd+F4QozPqn7FrSVHXmem3r7bjyHTxOgqxRCVa
+# 18Vtx7P/8bYSBeS+WHCKcliFCecspusCDSlnRUjZwyPdP0VHxaZg2unjHY3rMYIa
+# tjCCGrICAQEwfTBpMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIElu
+# Yy4xQTA/BgNVBAMTOERpZ2lDZXJ0IFRydXN0ZWQgRzQgQ29kZSBTaWduaW5nIFJT
+# QTQwOTYgU0hBMzg0IDIwMjEgQ0ExAhAHHxQbizANJfMU6yMM0NHdMA0GCWCGSAFl
+# AwQCAQUAoIHIMBkGCSqGSIb3DQEJAzEMBgorBgEEAYI3AgEEMBwGCisGAQQBgjcC
+# AQsxDjAMBgorBgEEAYI3AgEVMC8GCSqGSIb3DQEJBDEiBCBnAZ6P7YvTwq0fbF62
+# o7E75R0LxsW5OtyYiFESQckLhjBcBgorBgEEAYI3AgEMMU4wTKBGgEQAQgB1AGkA
+# bAB0ADoAIABSAGUAbABlAGEAcwBlAF8AdgAzAC4AMQAxAC4AOQBfADIAMAAyADQA
+# MAA0ADAAMgAuADAAMqECgAAwDQYJKoZIhvcNAQEBBQAEggIAg5wQO5NiKFirm9vr
+# 1//X5G4t+z318Uagu8vJT/vTjkMTau86CF+SwP3pqC1H2ZMUyVYmVHae5dswKAMR
+# hHY1VJV/0lJI+LdYcaxHI/WYzaFLbDrQI/Mty5cabjveG6geMlcJG4nYZlyQX+fJ
+# 1k0ogeIF1owldecXP8t5e10WlHBlWb8IBnIPwMtJVZ2/y8NASxsnSJE7pEe7ijGe
+# 5Bv9DXvoltKnMSVYv9u2vn7PeIq+Jm3n3kOGSIYtfdytEd1Fd6spfdcmIhqyzVk0
+# Hslq7Aqd7soT0xdmNa/amzEA4HRHpWGUhzOtcC+EqEIIJk9kTjyVgCiyWaB5gGko
+# OAZfsxQn+a916iWwA7RrQ+TzBZq/pleUTLZzJmI3DXFjuJ1NDP6Sdw6KREgx6Yw4
+# q2NnnodKlGZkMDcGYPTM2sA4i6i6FsznWY4d8wE4J261YeUrVfIyTx+Q81W4KXoi
+# C0x7Pe9Bjh4oJGM3YiLyhVL56sXZWxAC2C/vD3nvIvra9EpvlMvQh6b0xl0V4TSN
+# dJ7T7VttR/WNjau46JIgbGZWCDBTTUAydQNoAZ4KnCrcIZCN6Y0qVokXsYHsVIto
+# TsnM2+Ca09wxuOIfCOSKpAmqdJ/w2NwLwp+0gwrO2uzpCfbSbkAd+UQNv0joPyUp
+# ywmsQndxqA8TaADp8TfkkpJywJGhghc/MIIXOwYKKwYBBAGCNwMDATGCFyswghcn
+# BgkqhkiG9w0BBwKgghcYMIIXFAIBAzEPMA0GCWCGSAFlAwQCAQUAMHcGCyqGSIb3
+# DQEJEAEEoGgEZjBkAgEBBglghkgBhv1sBwEwMTANBglghkgBZQMEAgEFAAQg+Jhe
+# IOzOttA8vliuL+r3CiY4EJTzfvPasXkI/vwkoI8CEHZ95Ht1TmSmU8+fM0kIG00Y
+# DzIwMjQwNDAyMTIzMjEwWqCCEwkwggbCMIIEqqADAgECAhAFRK/zlJ0IOaa/2z9f
+# 5WEWMA0GCSqGSIb3DQEBCwUAMGMxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdp
+# Q2VydCwgSW5jLjE7MDkGA1UEAxMyRGlnaUNlcnQgVHJ1c3RlZCBHNCBSU0E0MDk2
+# IFNIQTI1NiBUaW1lU3RhbXBpbmcgQ0EwHhcNMjMwNzE0MDAwMDAwWhcNMzQxMDEz
+# MjM1OTU5WjBIMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4x
+# IDAeBgNVBAMTF0RpZ2lDZXJ0IFRpbWVzdGFtcCAyMDIzMIICIjANBgkqhkiG9w0B
+# AQEFAAOCAg8AMIICCgKCAgEAo1NFhx2DjlusPlSzI+DPn9fl0uddoQ4J3C9Io5d6
+# OyqcZ9xiFVjBqZMRp82qsmrdECmKHmJjadNYnDVxvzqX65RQjxwg6seaOy+WZuNp
+# 52n+W8PWKyAcwZeUtKVQgfLPywemMGjKg0La/H8JJJSkghraarrYO8pd3hkYhftF
+# 6g1hbJ3+cV7EBpo88MUueQ8bZlLjyNY+X9pD04T10Mf2SC1eRXWWdf7dEKEbg8G4
+# 5lKVtUfXeCk5a+B4WZfjRCtK1ZXO7wgX6oJkTf8j48qG7rSkIWRw69XloNpjsy7p
+# Be6q9iT1HbybHLK3X9/w7nZ9MZllR1WdSiQvrCuXvp/k/XtzPjLuUjT71Lvr1KAs
+# NJvj3m5kGQc3AZEPHLVRzapMZoOIaGK7vEEbeBlt5NkP4FhB+9ixLOFRr7StFQYU
+# 6mIIE9NpHnxkTZ0P387RXoyqq1AVybPKvNfEO2hEo6U7Qv1zfe7dCv95NBB+plwK
+# WEwAPoVpdceDZNZ1zY8SdlalJPrXxGshuugfNJgvOuprAbD3+yqG7HtSOKmYCaFx
+# smxxrz64b5bV4RAT/mFHCoz+8LbH1cfebCTwv0KCyqBxPZySkwS0aXAnDU+3tTbR
+# yV8IpHCj7ArxES5k4MsiK8rxKBMhSVF+BmbTO77665E42FEHypS34lCh8zrTioPL
+# QHsCAwEAAaOCAYswggGHMA4GA1UdDwEB/wQEAwIHgDAMBgNVHRMBAf8EAjAAMBYG
+# A1UdJQEB/wQMMAoGCCsGAQUFBwMIMCAGA1UdIAQZMBcwCAYGZ4EMAQQCMAsGCWCG
+# SAGG/WwHATAfBgNVHSMEGDAWgBS6FtltTYUvcyl2mi91jGogj57IbzAdBgNVHQ4E
+# FgQUpbbvE+fvzdBkodVWqWUxo97V40kwWgYDVR0fBFMwUTBPoE2gS4ZJaHR0cDov
+# L2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0VHJ1c3RlZEc0UlNBNDA5NlNIQTI1
+# NlRpbWVTdGFtcGluZ0NBLmNybDCBkAYIKwYBBQUHAQEEgYMwgYAwJAYIKwYBBQUH
+# MAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBYBggrBgEFBQcwAoZMaHR0cDov
+# L2NhY2VydHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0VHJ1c3RlZEc0UlNBNDA5NlNI
+# QTI1NlRpbWVTdGFtcGluZ0NBLmNydDANBgkqhkiG9w0BAQsFAAOCAgEAgRrW3qCp
+# tZgXvHCNT4o8aJzYJf/LLOTN6l0ikuyMIgKpuM+AqNnn48XtJoKKcS8Y3U623mzX
+# 4WCcK+3tPUiOuGu6fF29wmE3aEl3o+uQqhLXJ4Xzjh6S2sJAOJ9dyKAuJXglnSoF
+# eoQpmLZXeY/bJlYrsPOnvTcM2Jh2T1a5UsK2nTipgedtQVyMadG5K8TGe8+c+nji
+# kxp2oml101DkRBK+IA2eqUTQ+OVJdwhaIcW0z5iVGlS6ubzBaRm6zxbygzc0brBB
+# Jt3eWpdPM43UjXd9dUWhpVgmagNF3tlQtVCMr1a9TMXhRsUo063nQwBw3syYnhmJ
+# A+rUkTfvTVLzyWAhxFZH7doRS4wyw4jmWOK22z75X7BC1o/jF5HRqsBV44a/rCcs
+# QdCaM0qoNtS5cpZ+l3k4SF/Kwtw9Mt911jZnWon49qfH5U81PAC9vpwqbHkB3NpE
+# 5jreODsHXjlY9HxzMVWggBHLFAx+rrz+pOt5Zapo1iLKO+uagjVXKBbLafIymrLS
+# 2Dq4sUaGa7oX/cR3bBVsrquvczroSUa31X/MtjjA2Owc9bahuEMs305MfR5ocMB3
+# CtQC4Fxguyj/OOVSWtasFyIjTvTs0xf7UGv/B3cfcZdEQcm4RtNsMnxYL2dHZeUb
+# c7aZ+WssBkbvQR7w8F/g29mtkIBEr4AQQYowggauMIIElqADAgECAhAHNje3JFR8
+# 2Ees/ShmKl5bMA0GCSqGSIb3DQEBCwUAMGIxCzAJBgNVBAYTAlVTMRUwEwYDVQQK
+# EwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAfBgNV
+# BAMTGERpZ2lDZXJ0IFRydXN0ZWQgUm9vdCBHNDAeFw0yMjAzMjMwMDAwMDBaFw0z
+# NzAzMjIyMzU5NTlaMGMxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwg
+# SW5jLjE7MDkGA1UEAxMyRGlnaUNlcnQgVHJ1c3RlZCBHNCBSU0E0MDk2IFNIQTI1
+# NiBUaW1lU3RhbXBpbmcgQ0EwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC
+# AQDGhjUGSbPBPXJJUVXHJQPE8pE3qZdRodbSg9GeTKJtoLDMg/la9hGhRBVCX6SI
+# 82j6ffOciQt/nR+eDzMfUBMLJnOWbfhXqAJ9/UO0hNoR8XOxs+4rgISKIhjf69o9
+# xBd/qxkrPkLcZ47qUT3w1lbU5ygt69OxtXXnHwZljZQp09nsad/ZkIdGAHvbREGJ
+# 3HxqV3rwN3mfXazL6IRktFLydkf3YYMZ3V+0VAshaG43IbtArF+y3kp9zvU5Emfv
+# DqVjbOSmxR3NNg1c1eYbqMFkdECnwHLFuk4fsbVYTXn+149zk6wsOeKlSNbwsDET
+# qVcplicu9Yemj052FVUmcJgmf6AaRyBD40NjgHt1biclkJg6OBGz9vae5jtb7IHe
+# IhTZgirHkr+g3uM+onP65x9abJTyUpURK1h0QCirc0PO30qhHGs4xSnzyqqWc0Jo
+# n7ZGs506o9UD4L/wojzKQtwYSH8UNM/STKvvmz3+DrhkKvp1KCRB7UK/BZxmSVJQ
+# 9FHzNklNiyDSLFc1eSuo80VgvCONWPfcYd6T/jnA+bIwpUzX6ZhKWD7TA4j+s4/T
+# Xkt2ElGTyYwMO1uKIqjBJgj5FBASA31fI7tk42PgpuE+9sJ0sj8eCXbsq11GdeJg
+# o1gJASgADoRU7s7pXcheMBK9Rp6103a50g5rmQzSM7TNsQIDAQABo4IBXTCCAVkw
+# EgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUuhbZbU2FL3MpdpovdYxqII+e
+# yG8wHwYDVR0jBBgwFoAU7NfjgtJxXWRM3y5nP+e6mK4cD08wDgYDVR0PAQH/BAQD
+# AgGGMBMGA1UdJQQMMAoGCCsGAQUFBwMIMHcGCCsGAQUFBwEBBGswaTAkBggrBgEF
+# BQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEEGCCsGAQUFBzAChjVodHRw
+# Oi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRUcnVzdGVkUm9vdEc0LmNy
+# dDBDBgNVHR8EPDA6MDigNqA0hjJodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vRGln
+# aUNlcnRUcnVzdGVkUm9vdEc0LmNybDAgBgNVHSAEGTAXMAgGBmeBDAEEAjALBglg
+# hkgBhv1sBwEwDQYJKoZIhvcNAQELBQADggIBAH1ZjsCTtm+YqUQiAX5m1tghQuGw
+# GC4QTRPPMFPOvxj7x1Bd4ksp+3CKDaopafxpwc8dB+k+YMjYC+VcW9dth/qEICU0
+# MWfNthKWb8RQTGIdDAiCqBa9qVbPFXONASIlzpVpP0d3+3J0FNf/q0+KLHqrhc1D
+# X+1gtqpPkWaeLJ7giqzl/Yy8ZCaHbJK9nXzQcAp876i8dU+6WvepELJd6f8oVInw
+# 1YpxdmXazPByoyP6wCeCRK6ZJxurJB4mwbfeKuv2nrF5mYGjVoarCkXJ38SNoOeY
+# +/umnXKvxMfBwWpx2cYTgAnEtp/Nh4cku0+jSbl3ZpHxcpzpSwJSpzd+k1OsOx0I
+# SQ+UzTl63f8lY5knLD0/a6fxZsNBzU+2QJshIUDQtxMkzdwdeDrknq3lNHGS1yZr
+# 5Dhzq6YBT70/O3itTK37xJV77QpfMzmHQXh6OOmc4d0j/R0o08f56PGYX/sr2H7y
+# Rp11LB4nLCbbbxV7HhmLNriT1ObyF5lZynDwN7+YAN8gFk8n+2BnFqFmut1VwDop
+# hrCYoCvtlUG3OtUVmDG0YgkPCr2B2RP+v6TR81fZvAT6gt4y3wSJ8ADNXcL50CN/
+# AAvkdgIm2fBldkKmKYcJRyvmfxqkhQ/8mJb2VVQrH4D6wPIOK+XW+6kvRBVK5xMO
+# Hds3OBqhK/bt1nz8MIIFjTCCBHWgAwIBAgIQDpsYjvnQLefv21DiCEAYWjANBgkq
+# hkiG9w0BAQwFADBlMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5j
+# MRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBB
+# c3N1cmVkIElEIFJvb3QgQ0EwHhcNMjIwODAxMDAwMDAwWhcNMzExMTA5MjM1OTU5
+# WjBiMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQL
+# ExB3d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJv
+# b3QgRzQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1K
+# PDAiMGkz7MKnJS7JIT3yithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2r
+# snnyyhHS5F/WBTxSD1Ifxp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C
+# 8weE5nQ7bXHiLQwb7iDVySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBf
+# sXpm7nfISKhmV1efVFiODCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGY
+# QJB5w3jHtrHEtWoYOAMQjdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8
+# rhsDdV14Ztk6MUSaM0C/CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaY
+# dj1ZXUJ2h4mXaXpI8OCiEhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+
+# wJS00mFt6zPZxd9LBADMfRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw
+# ++hkpjPRiQfhvbfmQ6QYuKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+N
+# P8m800ERElvlEFDrMcXKchYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7F
+# wI+isX4KJpn15GkvmB0t9dmpsh3lGwIDAQABo4IBOjCCATYwDwYDVR0TAQH/BAUw
+# AwEB/zAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wHwYDVR0jBBgwFoAU
+# Reuir/SSy4IxLVGLp6chnfNtyA8wDgYDVR0PAQH/BAQDAgGGMHkGCCsGAQUFBwEB
+# BG0wazAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEMGCCsG
+# AQUFBzAChjdodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1
+# cmVkSURSb290Q0EuY3J0MEUGA1UdHwQ+MDwwOqA4oDaGNGh0dHA6Ly9jcmwzLmRp
+# Z2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRFJvb3RDQS5jcmwwEQYDVR0gBAow
+# CDAGBgRVHSAAMA0GCSqGSIb3DQEBDAUAA4IBAQBwoL9DXFXnOF+go3QbPbYW1/e/
+# Vwe9mqyhhyzshV6pGrsi+IcaaVQi7aSId229GhT0E0p6Ly23OO/0/4C5+KH38nLe
+# JLxSA8hO0Cre+i1Wz/n096wwepqLsl7Uz9FDRJtDIeuWcqFItJnLnU+nBgMTdydE
+# 1Od/6Fmo8L8vC6bp8jQ87PcDx4eo0kxAGTVGamlUsLihVo7spNU96LHc/RzY9Hda
+# XFSMb++hUD38dglohJ9vytsgjTVgHAIDyyCwrFigDkBjxZgiwbJZ9VVrzyerbHbO
+# byMt9H5xaiNrIv8SuFQtJ37YOtnwtoeW/VvRXKwYw02fc7cBqZ9Xql4o4rmUMYID
+# djCCA3ICAQEwdzBjMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIElu
+# Yy4xOzA5BgNVBAMTMkRpZ2lDZXJ0IFRydXN0ZWQgRzQgUlNBNDA5NiBTSEEyNTYg
+# VGltZVN0YW1waW5nIENBAhAFRK/zlJ0IOaa/2z9f5WEWMA0GCWCGSAFlAwQCAQUA
+# oIHRMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcN
+# MjQwNDAyMTIzMjEwWjArBgsqhkiG9w0BCRACDDEcMBowGDAWBBRm8CsywsLJD4Jd
+# zqqKycZPGZzPQDAvBgkqhkiG9w0BCQQxIgQg58bvIvjFkyBb2O0xwLgtU8RJLcMV
+# kvIdXiq3TCLuhq4wNwYLKoZIhvcNAQkQAi8xKDAmMCQwIgQg0vbkbe10IszR1EBX
+# aEE2b4KK2lWarjMWr00amtQMeCgwDQYJKoZIhvcNAQEBBQAEggIAhU3imuIvql4+
+# IqPz0Anf0ZIB5hbafNTx1WEVhPEG9iJr24gpjbWvepQrbWJf0FBj8wY9GeRab6iv
+# 79MMxZkPpR/DMK1qFr1vIlw67JhpqqNkaNIa5G3pAHDYdHYcB+Utw1p5XPOBRu0A
+# f4wQ5fwWugys4CGGAboq4prLNRKeUGVexMDK7Eorsv9xmzK0tE9QSMA3SxLCcSIX
+# mrMkKzTR3vn0dqaDG4Ge7U2w7dVnQYGBX+s6C9CCjvCtenCAQLbF+OyYhkMNDVtJ
+# lTmzxxwyyA5fFZJpG/Wfo/84/P8lQXUTuwOBpFoLE65OqNEG03SoqKsW4aTqkVM7
+# b6fKLsygm1w23+UlHGF/fbExeqxgOZiuJWWt/OFy9T3HIcAF1SMh7mot5ciu7btS
+# xjkr/fhsi1M3M1g/giyn0I8N24mgaICPtXAzAbZW7GSC0R5T2qnW6gYoAcY62Qdz
+# jl/Ey1rnOQ26TuQODyPVHhfhoIBbdIDpDJ2Vu2mxyxUnjATbizphcBgsU1fBYvZR
+# v+SuK1MYZOGqgzugfiufdeFAlBDA/e64yRkJvDBEkcyGvj6FS6nVm7ekJpJhLU3z
+# sSSmcYwdx1YQCr48HEjcmGrj5sAzzg4U4WU/GrLWz2sSRmh5rKcDAa0ewfYi13Z2
+# a/cdr8Or2RQ5ZSQ8OHgr3GBw7koDWR8=
+# SIG # End signature block
diff --git a/runtime/python/prompty/.venv_new/Scripts/activate b/runtime/python/prompty/.venv_new/Scripts/activate
new file mode 100644
index 00000000..c8b55d6e
--- /dev/null
+++ b/runtime/python/prompty/.venv_new/Scripts/activate
@@ -0,0 +1,63 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past commands. Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="C:\Users\sejuare\.copilot\copilot-worktrees\prompty\sethjuarez-unsalivated-sharan\runtime\python\prompty\.venv_new"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/Scripts:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="(.venv_new) ${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT="(.venv_new) "
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null
diff --git a/runtime/python/prompty/.venv_new/Scripts/activate.bat b/runtime/python/prompty/.venv_new/Scripts/activate.bat
new file mode 100644
index 00000000..c0a74052
--- /dev/null
+++ b/runtime/python/prompty/.venv_new/Scripts/activate.bat
@@ -0,0 +1,34 @@
+@echo off
+
+rem This file is UTF-8 encoded, so we need to update the current code page while executing it
+for /f "tokens=2 delims=:." %%a in ('"%SystemRoot%\System32\chcp.com"') do (
+    set _OLD_CODEPAGE=%%a
+)
+if defined _OLD_CODEPAGE (
+    "%SystemRoot%\System32\chcp.com" 65001 > nul
+)
+
+set VIRTUAL_ENV=C:\Users\sejuare\.copilot\copilot-worktrees\prompty\sethjuarez-unsalivated-sharan\runtime\python\prompty\.venv_new
+
+if not defined PROMPT set PROMPT=$P$G
+
+if defined _OLD_VIRTUAL_PROMPT set PROMPT=%_OLD_VIRTUAL_PROMPT%
+if defined _OLD_VIRTUAL_PYTHONHOME set PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%
+
+set _OLD_VIRTUAL_PROMPT=%PROMPT%
+set PROMPT=(.venv_new) %PROMPT%
+
+if defined PYTHONHOME set _OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%
+set PYTHONHOME=
+
+if defined _OLD_VIRTUAL_PATH set PATH=%_OLD_VIRTUAL_PATH%
+if not defined _OLD_VIRTUAL_PATH set _OLD_VIRTUAL_PATH=%PATH%
+
+set PATH=%VIRTUAL_ENV%\Scripts;%PATH%
+set VIRTUAL_ENV_PROMPT=(.venv_new) 
+
+:END
+if defined _OLD_CODEPAGE (
+    "%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul
+    set _OLD_CODEPAGE=
+)
diff --git a/runtime/python/prompty/.venv_new/Scripts/coverage-3.11.exe b/runtime/python/prompty/.venv_new/Scripts/coverage-3.11.exe
new file mode 100644
index 00000000..eb52b0f5
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/coverage-3.11.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/coverage.exe b/runtime/python/prompty/.venv_new/Scripts/coverage.exe
new file mode 100644
index 00000000..3d0c6d3e
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/coverage.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/coverage3.exe b/runtime/python/prompty/.venv_new/Scripts/coverage3.exe
new file mode 100644
index 00000000..eb52b0f5
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/coverage3.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/deactivate.bat b/runtime/python/prompty/.venv_new/Scripts/deactivate.bat
new file mode 100644
index 00000000..62a39a75
--- /dev/null
+++ b/runtime/python/prompty/.venv_new/Scripts/deactivate.bat
@@ -0,0 +1,22 @@
+@echo off
+
+if defined _OLD_VIRTUAL_PROMPT (
+    set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
+)
+set _OLD_VIRTUAL_PROMPT=
+
+if defined _OLD_VIRTUAL_PYTHONHOME (
+    set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%"
+    set _OLD_VIRTUAL_PYTHONHOME=
+)
+
+if defined _OLD_VIRTUAL_PATH (
+    set "PATH=%_OLD_VIRTUAL_PATH%"
+)
+
+set _OLD_VIRTUAL_PATH=
+
+set VIRTUAL_ENV=
+set VIRTUAL_ENV_PROMPT=
+
+:END
diff --git a/runtime/python/prompty/.venv_new/Scripts/dotenv.exe b/runtime/python/prompty/.venv_new/Scripts/dotenv.exe
new file mode 100644
index 00000000..9f220fd4
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/dotenv.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/pip.exe b/runtime/python/prompty/.venv_new/Scripts/pip.exe
new file mode 100644
index 00000000..0ba195b2
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/pip.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/pip3.11.exe b/runtime/python/prompty/.venv_new/Scripts/pip3.11.exe
new file mode 100644
index 00000000..0ba195b2
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/pip3.11.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/pip3.exe b/runtime/python/prompty/.venv_new/Scripts/pip3.exe
new file mode 100644
index 00000000..0ba195b2
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/pip3.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/py.test.exe b/runtime/python/prompty/.venv_new/Scripts/py.test.exe
new file mode 100644
index 00000000..df9ca5fe
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/py.test.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/pygmentize.exe b/runtime/python/prompty/.venv_new/Scripts/pygmentize.exe
new file mode 100644
index 00000000..5f0a68de
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/pygmentize.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/pytest.exe b/runtime/python/prompty/.venv_new/Scripts/pytest.exe
new file mode 100644
index 00000000..df9ca5fe
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/pytest.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/python.exe b/runtime/python/prompty/.venv_new/Scripts/python.exe
new file mode 100644
index 00000000..f7cb1e38
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/python.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/pythonw.exe b/runtime/python/prompty/.venv_new/Scripts/pythonw.exe
new file mode 100644
index 00000000..4fc3f909
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/pythonw.exe differ
diff --git a/runtime/python/prompty/.venv_new/Scripts/ruff.exe b/runtime/python/prompty/.venv_new/Scripts/ruff.exe
new file mode 100644
index 00000000..731fc10e
Binary files /dev/null and b/runtime/python/prompty/.venv_new/Scripts/ruff.exe differ
diff --git a/runtime/python/prompty/.venv_new/pyvenv.cfg b/runtime/python/prompty/.venv_new/pyvenv.cfg
new file mode 100644
index 00000000..10b3d69b
--- /dev/null
+++ b/runtime/python/prompty/.venv_new/pyvenv.cfg
@@ -0,0 +1,5 @@
+home = C:\Users\sejuare\AppData\Local\Microsoft\WindowsApps\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0
+include-system-site-packages = false
+version = 3.11.9
+executable = C:\Users\sejuare\AppData\Local\Microsoft\WindowsApps\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\python.exe
+command = C:\Users\sejuare\AppData\Local\Microsoft\WindowsApps\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\python.exe -m venv C:\Users\sejuare\.copilot\copilot-worktrees\prompty\sethjuarez-unsalivated-sharan\runtime\python\prompty\.venv_new
diff --git a/runtime/python/prompty/prompty/core/types.py b/runtime/python/prompty/prompty/core/types.py
index 04c29762..b5ae4ee5 100644
--- a/runtime/python/prompty/prompty/core/types.py
+++ b/runtime/python/prompty/prompty/core/types.py
@@ -1,27 +1,46 @@
-"""Abstract message types for model-agnostic prompt representation.
+"""Runtime extensions for the generated Message class.
 
-The parser produces these types. Executors transform them into
-provider-specific wire format (OpenAI, Anthropic, etc.).
+The canonical type definitions (``Message``, ``ContentPart``, ``TextPart``, etc.)
+and the ``MessageHelpers`` Protocol contract are generated by the TypeSpec
+emitter and live in ``prompty.model``. This module re-exports them, provides
+the Protocol-conforming ``text()``/``to_text_content()`` implementations, and
+defines runtime-only streaming wrappers.
+
+The generated :class:`~prompty.model.MessageHelpers` Protocol is
+``@runtime_checkable`` — a module-level ``isinstance`` assertion below
+confirms the attached methods satisfy the contract.
 
-Also provides streaming wrappers (``PromptyStream``, ``AsyncPromptyStream``)
-that accumulate chunks and flush to the tracer on exhaustion.
+The parser produces ``Message`` objects. Executors transform them into
+provider-specific wire format (OpenAI, Anthropic, etc.).
 """
 
 from __future__ import annotations
 
 from collections.abc import AsyncIterator, Iterator
-from dataclasses import dataclass, field
 from typing import Any
 
+# Re-export generated types — these are the canonical definitions.
+from ..model import (
+    AudioPart,
+    ContentPart,
+    FilePart,
+    ImagePart,
+    Message,
+    MessageHelpers,
+    TextPart,
+    ThreadMarker,
+)
+
 __all__ = [
     "AsyncPromptyStream",
+    "AudioPart",
     "ContentPart",
-    "ImagePart",
     "FilePart",
-    "AudioPart",
-    "TextPart",
+    "ImagePart",
     "Message",
+    "MessageHelpers",
     "PromptyStream",
+    "TextPart",
     "ThreadMarker",
     "RICH_KINDS",
     "ROLES",
@@ -35,124 +54,41 @@
 
 
 # ---------------------------------------------------------------------------
-# Content parts
+# MessageHelpers implementation — attached to the generated Message class
 # ---------------------------------------------------------------------------
 
 
-@dataclass
-class ContentPart:
-    """Base class for typed content within a message.
-
-    Each part has a ``kind`` discriminator and part-specific fields.
-    """
+def _message_text(self: Message) -> str:
+    """Concatenate all TextPart values into a single string."""
+    return "".join(p.value for p in self.parts if isinstance(p, TextPart))
 
-    kind: str
 
+def _message_to_text_content(self: Message) -> str | list[dict[str, Any]]:
+    """Return plain string if all parts are text, else a parts list.
 
-@dataclass
-class TextPart(ContentPart):
-    """Plain text content."""
-
-    kind: str = field(default="text", init=False)
-    value: str = ""
-
-
-@dataclass
-class ImagePart(ContentPart):
-    """Image content — URL, data URI, or file path.
-
-    Attributes:
-        source: URL, ``data:`` URI, or file path to the image.
-        detail: Processing detail level (``"auto"``, ``"low"``, ``"high"``).
-        media_type: MIME type (e.g. ``"image/png"``). Inferred if omitted.
+    This is useful for simple serialization — callers that only need
+    the text content can get a ``str``, while multimodal messages
+    get the full parts array.
     """
-
-    kind: str = field(default="image", init=False)
-    source: str = ""
-    detail: str | None = None
-    media_type: str | None = None
-
-
-@dataclass
-class FilePart(ContentPart):
-    """File/document attachment (PDF, etc.).
-
-    Attributes:
-        source: URL or file path.
-        media_type: MIME type (e.g. ``"application/pdf"``).
-    """
-
-    kind: str = field(default="file", init=False)
-    source: str = ""
-    media_type: str | None = None
-
-
-@dataclass
-class AudioPart(ContentPart):
-    """Audio content.
-
-    Attributes:
-        source: URL, ``data:`` URI, or file path.
-        media_type: MIME type (e.g. ``"audio/wav"``).
-    """
-
-    kind: str = field(default="audio", init=False)
-    source: str = ""
-    media_type: str | None = None
-
-
-# ---------------------------------------------------------------------------
-# Messages
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class Message:
-    """A single message in the abstract message array.
-
-    Attributes:
-        role: One of the recognized roles (system, user, assistant, developer).
-        parts: Ordered list of content parts.
-        metadata: Extra key-value pairs from role boundary args
-            (e.g. ``name``, custom attributes).
-    """
-
-    role: str
-    parts: list[ContentPart] = field(default_factory=list)
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-    @property
-    def text(self) -> str:
-        """Convenience: concatenate all TextPart values."""
-        return "".join(p.value for p in self.parts if isinstance(p, TextPart))
-
-    def to_text_content(self) -> str | list[dict[str, Any]]:
-        """Return plain string if all parts are text, else a parts list.
-
-        This is useful for simple serialization — callers that only need
-        the text content can get a ``str``, while multimodal messages
-        get the full parts array.
-        """
-        if all(isinstance(p, TextPart) for p in self.parts):
-            return self.text
-        return [_part_to_dict(p) for p in self.parts]
-
-
-@dataclass
-class ThreadMarker:
-    """Positional marker for rich-kind input insertion.
-
-    Emitted during prepare when the renderer nonce for a rich-kind input
-    (thread, image, file, audio) is found in parsed message text.
-    ``prepare()`` replaces these with actual content from the inputs.
-
-    Attributes:
-        name: The input property name (e.g. ``"conversation"``).
-        kind: The rich kind (``"thread"``, ``"image"``, ``"file"``, ``"audio"``).
-    """
-
-    name: str = "thread"
-    kind: str = "thread"
+    if all(isinstance(p, TextPart) for p in self.parts):
+        return _message_text(self)
+    return [_part_to_dict(p) for p in self.parts]
+
+
+# Bind the MessageHelpers contract methods to the generated class. The
+# generated Protocol declares ``text`` as a ``@property`` (zero-param,
+# non-verb name) and ``to_text_content()`` as a method (verb prefix ``to``),
+# so we attach them accordingly.
+Message.text = property(_message_text)  # type: ignore[attr-defined]
+Message.to_text_content = _message_to_text_content  # type: ignore[attr-defined]
+
+# Verify the attached methods satisfy the generated Protocol contract.
+# If this assertion ever fails, the emitter added a new @method declaration
+# on Message that we have not implemented yet.
+assert isinstance(
+    Message(role="user", parts=[], metadata={}),
+    MessageHelpers,
+), "Message does not satisfy the generated MessageHelpers Protocol contract"
 
 
 # ---------------------------------------------------------------------------
diff --git a/runtime/python/prompty/prompty/model/_Binding.py b/runtime/python/prompty/prompty/model/_Binding.py
index 2b75bd0f..0e347fdf 100644
--- a/runtime/python/prompty/prompty/model/_Binding.py
+++ b/runtime/python/prompty/prompty/model/_Binding.py
@@ -43,7 +43,11 @@ def load(data: Any, context: LoadContext | None = None) -> "Binding":
 
         # handle alternate representations
         if isinstance(data, str):
-            data = {"input": data}
+            instance = Binding()
+            instance.input = data
+            if context is not None:
+                instance = context.process_output(instance)
+            return instance
 
         if not isinstance(data, dict):
             raise ValueError(f"Invalid data for Binding: {data}")
diff --git a/runtime/python/prompty/prompty/model/_CompactionCompletePayload.py b/runtime/python/prompty/prompty/model/_CompactionCompletePayload.py
new file mode 100644
index 00000000..7b385e3d
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_CompactionCompletePayload.py
@@ -0,0 +1,104 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class CompactionCompletePayload:
+    """Payload for "compaction_complete" events — context compaction finished.
+
+    Attributes
+    ----------
+    removed : int
+        Number of messages removed during compaction
+    remaining : int
+        Number of messages remaining after compaction
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    removed: int = field(default=0)
+    remaining: int = field(default=0)
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "CompactionCompletePayload":
+        """Load a CompactionCompletePayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            CompactionCompletePayload: The loaded CompactionCompletePayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for CompactionCompletePayload: {data}")
+
+        # create new instance
+        instance = CompactionCompletePayload()
+
+        if data is not None and "removed" in data:
+            instance.removed = data["removed"]
+        if data is not None and "remaining" in data:
+            instance.remaining = data["remaining"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the CompactionCompletePayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.removed is not None:
+            result["removed"] = obj.removed
+        if obj.remaining is not None:
+            result["remaining"] = obj.remaining
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the CompactionCompletePayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the CompactionCompletePayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_CompactionConfig.py b/runtime/python/prompty/prompty/model/_CompactionConfig.py
new file mode 100644
index 00000000..ee62e127
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_CompactionConfig.py
@@ -0,0 +1,113 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class CompactionConfig:
+    """Configuration for context window compaction. When the message history
+    exceeds the context budget, the compaction strategy is applied to
+    reduce the message list while preserving essential information.
+
+    Attributes
+    ----------
+    strategy : Optional[str]
+        The compaction strategy identifier. Built-in strategies include 'summarize'. Can also be a path to a .prompty file used as the summarization prompt.
+    budget : Optional[int]
+        Character budget for the compacted context. Overrides TurnOptions.contextBudget when set.
+    options : Optional[dict[str, Any]]
+        Additional strategy-specific options
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    strategy: str | None = None
+    budget: int | None = None
+    options: dict[str, Any] | None = None
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "CompactionConfig":
+        """Load a CompactionConfig instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            CompactionConfig: The loaded CompactionConfig instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for CompactionConfig: {data}")
+
+        # create new instance
+        instance = CompactionConfig()
+
+        if data is not None and "strategy" in data:
+            instance.strategy = data["strategy"]
+        if data is not None and "budget" in data:
+            instance.budget = data["budget"]
+        if data is not None and "options" in data:
+            instance.options = data["options"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the CompactionConfig instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.strategy is not None:
+            result["strategy"] = obj.strategy
+        if obj.budget is not None:
+            result["budget"] = obj.budget
+        if obj.options is not None:
+            result["options"] = obj.options
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the CompactionConfig instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the CompactionConfig instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_CompactionFailedPayload.py b/runtime/python/prompty/prompty/model/_CompactionFailedPayload.py
new file mode 100644
index 00000000..efc5a758
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_CompactionFailedPayload.py
@@ -0,0 +1,97 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class CompactionFailedPayload:
+    """Payload for "compaction_failed" events — compaction could not be completed.
+
+    Attributes
+    ----------
+    message : str
+        Explanation of why compaction failed
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    message: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "CompactionFailedPayload":
+        """Load a CompactionFailedPayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            CompactionFailedPayload: The loaded CompactionFailedPayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for CompactionFailedPayload: {data}")
+
+        # create new instance
+        instance = CompactionFailedPayload()
+
+        if data is not None and "message" in data:
+            instance.message = data["message"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the CompactionFailedPayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.message is not None:
+            result["message"] = obj.message
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the CompactionFailedPayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the CompactionFailedPayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_Connection.py b/runtime/python/prompty/prompty/model/_Connection.py
index 41d3c3c4..b2fb6272 100644
--- a/runtime/python/prompty/prompty/model/_Connection.py
+++ b/runtime/python/prompty/prompty/model/_Connection.py
@@ -21,17 +21,17 @@ class Connection(ABC):
     ----------
     kind : str
         The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens)
-    authenticationMode : Optional[str]
+    authentication_mode : Optional[str]
         The authority level for the connection, indicating under whose authority the connection is made (e.g., 'user', 'agent', 'system')
-    usageDescription : Optional[str]
+    usage_description : Optional[str]
         The usage description for the connection, providing context on how this connection will be used
     """
 
     _shorthand_property: ClassVar[str | None] = None
 
     kind: str = field(default="")
-    authenticationMode: str | None = None
-    usageDescription: str | None = None
+    authentication_mode: str | None = None
+    usage_description: str | None = None
 
     @staticmethod
     def load(data: Any, context: LoadContext | None = None) -> "Connection":
@@ -56,9 +56,9 @@ def load(data: Any, context: LoadContext | None = None) -> "Connection":
         if data is not None and "kind" in data:
             instance.kind = data["kind"]
         if data is not None and "authenticationMode" in data:
-            instance.authenticationMode = data["authenticationMode"]
+            instance.authentication_mode = data["authenticationMode"]
         if data is not None and "usageDescription" in data:
-            instance.usageDescription = data["usageDescription"]
+            instance.usage_description = data["usageDescription"]
         if context is not None:
             instance = context.process_output(instance)
         return instance
@@ -76,10 +76,10 @@ def load_kind(data: dict, context: LoadContext | None) -> "Connection":
                 return ApiKeyConnection.load(data, context)
             elif discriminator_value == "anonymous":
                 return AnonymousConnection.load(data, context)
-            elif discriminator_value == "foundry":
-                return FoundryConnection.load(data, context)
             elif discriminator_value == "oauth":
                 return OAuthConnection.load(data, context)
+            elif discriminator_value == "foundry":
+                return FoundryConnection.load(data, context)
 
             else:
                 raise ValueError(f"Unknown Connection discriminator value: {discriminator_value}")
@@ -102,10 +102,10 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
 
         if obj.kind is not None:
             result["kind"] = obj.kind
-        if obj.authenticationMode is not None:
-            result["authenticationMode"] = obj.authenticationMode
-        if obj.usageDescription is not None:
-            result["usageDescription"] = obj.usageDescription
+        if obj.authentication_mode is not None:
+            result["authenticationMode"] = obj.authentication_mode
+        if obj.usage_description is not None:
+            result["usageDescription"] = obj.usage_description
 
         if context is not None:
             result = context.process_dict(result)
@@ -208,7 +208,6 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["name"] = obj.name
         if obj.target is not None:
             result["target"] = obj.target
-
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
@@ -308,7 +307,6 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["name"] = obj.name
         if obj.endpoint is not None:
             result["endpoint"] = obj.endpoint
-
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
@@ -347,7 +345,7 @@ class ApiKeyConnection(Connection):
         The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens)
     endpoint : str
         The endpoint URL for the AI service
-    apiKey : str
+    api_key : str
         The API key for authenticating with the AI service
     """
 
@@ -355,7 +353,7 @@ class ApiKeyConnection(Connection):
 
     kind: str = field(default="key")
     endpoint: str = field(default="")
-    apiKey: str = field(default="")
+    api_key: str = field(default="")
 
     @staticmethod
     def load(data: Any, context: LoadContext | None = None) -> "ApiKeyConnection":
@@ -382,7 +380,7 @@ def load(data: Any, context: LoadContext | None = None) -> "ApiKeyConnection":
         if data is not None and "endpoint" in data:
             instance.endpoint = data["endpoint"]
         if data is not None and "apiKey" in data:
-            instance.apiKey = data["apiKey"]
+            instance.api_key = data["apiKey"]
         if context is not None:
             instance = context.process_output(instance)
         return instance
@@ -406,9 +404,8 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["kind"] = obj.kind
         if obj.endpoint is not None:
             result["endpoint"] = obj.endpoint
-        if obj.apiKey is not None:
-            result["apiKey"] = obj.apiKey
-
+        if obj.api_key is not None:
+            result["apiKey"] = obj.api_key
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
@@ -501,7 +498,6 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["kind"] = obj.kind
         if obj.endpoint is not None:
             result["endpoint"] = obj.endpoint
-
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
@@ -531,38 +527,44 @@ def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
 
 
 @dataclass
-class FoundryConnection(Connection):
-    """Connection configuration for Microsoft Foundry projects.
-    Provides project-scoped access to models, tools, and services
-    via Entra ID (DefaultAzureCredential) authentication.
+class OAuthConnection(Connection):
+    """Connection configuration using OAuth 2.0 client credentials.
+    Useful for tools and services that require OAuth authentication,
+    such as MCP servers, OpenAPI endpoints, or other REST APIs.
 
     Attributes
     ----------
     kind : str
-        The connection kind for Foundry project access
+        The connection kind for OAuth authentication
     endpoint : str
-        The Foundry project endpoint URL
-    name : Optional[str]
-        The named connection within the Foundry project
-    connectionType : Optional[str]
-        The connection type within the Foundry project (e.g., 'model', 'index', 'storage')
+        The endpoint URL for the service
+    client_id : str
+        The OAuth client ID
+    client_secret : str
+        The OAuth client secret
+    token_url : str
+        The OAuth token endpoint URL
+    scopes : Optional[list[str]]
+        OAuth scopes to request
     """
 
     _shorthand_property: ClassVar[str | None] = None
 
-    kind: str = field(default="foundry")
+    kind: str = field(default="oauth")
     endpoint: str = field(default="")
-    name: str | None = None
-    connectionType: str | None = None
+    client_id: str = field(default="")
+    client_secret: str = field(default="")
+    token_url: str = field(default="")
+    scopes: list[str] = field(default_factory=list)
 
     @staticmethod
-    def load(data: Any, context: LoadContext | None = None) -> "FoundryConnection":
-        """Load a FoundryConnection instance.
+    def load(data: Any, context: LoadContext | None = None) -> "OAuthConnection":
+        """Load a OAuthConnection instance.
         Args:
             data (Any): The data to load the instance from.
             context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
         Returns:
-            FoundryConnection: The loaded FoundryConnection instance.
+            OAuthConnection: The loaded OAuthConnection instance.
 
         """
 
@@ -570,25 +572,29 @@ def load(data: Any, context: LoadContext | None = None) -> "FoundryConnection":
             data = context.process_input(data)
 
         if not isinstance(data, dict):
-            raise ValueError(f"Invalid data for FoundryConnection: {data}")
+            raise ValueError(f"Invalid data for OAuthConnection: {data}")
 
         # create new instance
-        instance = FoundryConnection()
+        instance = OAuthConnection()
 
         if data is not None and "kind" in data:
             instance.kind = data["kind"]
         if data is not None and "endpoint" in data:
             instance.endpoint = data["endpoint"]
-        if data is not None and "name" in data:
-            instance.name = data["name"]
-        if data is not None and "connectionType" in data:
-            instance.connectionType = data["connectionType"]
+        if data is not None and "clientId" in data:
+            instance.client_id = data["clientId"]
+        if data is not None and "clientSecret" in data:
+            instance.client_secret = data["clientSecret"]
+        if data is not None and "tokenUrl" in data:
+            instance.token_url = data["tokenUrl"]
+        if data is not None and "scopes" in data:
+            instance.scopes = data["scopes"]
         if context is not None:
             instance = context.process_output(instance)
         return instance
 
     def save(self, context: SaveContext | None = None) -> dict[str, Any]:
-        """Save the FoundryConnection instance to a dictionary.
+        """Save the OAuthConnection instance to a dictionary.
         Args:
             context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
         Returns:
@@ -606,15 +612,18 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["kind"] = obj.kind
         if obj.endpoint is not None:
             result["endpoint"] = obj.endpoint
-        if obj.name is not None:
-            result["name"] = obj.name
-        if obj.connectionType is not None:
-            result["connectionType"] = obj.connectionType
-
+        if obj.client_id is not None:
+            result["clientId"] = obj.client_id
+        if obj.client_secret is not None:
+            result["clientSecret"] = obj.client_secret
+        if obj.token_url is not None:
+            result["tokenUrl"] = obj.token_url
+        if obj.scopes is not None:
+            result["scopes"] = obj.scopes
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
-        """Convert the FoundryConnection instance to a YAML string.
+        """Convert the OAuthConnection instance to a YAML string.
         Args:
             context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
         Returns:
@@ -626,7 +635,7 @@ def to_yaml(self, context: SaveContext | None = None) -> str:
         return context.to_yaml(self.save(context))
 
     def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
-        """Convert the FoundryConnection instance to a JSON string.
+        """Convert the OAuthConnection instance to a JSON string.
         Args:
             context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
             indent (int): Number of spaces for indentation. Defaults to 2.
@@ -640,44 +649,38 @@ def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
 
 
 @dataclass
-class OAuthConnection(Connection):
-    """Connection configuration using OAuth 2.0 client credentials.
-    Useful for tools and services that require OAuth authentication,
-    such as MCP servers, OpenAPI endpoints, or other REST APIs.
+class FoundryConnection(Connection):
+    """Connection configuration for Microsoft Foundry projects.
+    Provides project-scoped access to models, tools, and services
+    via Entra ID (DefaultAzureCredential) authentication.
 
     Attributes
     ----------
     kind : str
-        The connection kind for OAuth authentication
+        The connection kind for Foundry project access
     endpoint : str
-        The endpoint URL for the service
-    clientId : str
-        The OAuth client ID
-    clientSecret : str
-        The OAuth client secret
-    tokenUrl : str
-        The OAuth token endpoint URL
-    scopes : list[str]
-        OAuth scopes to request
+        The Foundry project endpoint URL
+    name : Optional[str]
+        The named connection within the Foundry project
+    connection_type : Optional[str]
+        The connection type within the Foundry project (e.g., 'model', 'index', 'storage')
     """
 
     _shorthand_property: ClassVar[str | None] = None
 
-    kind: str = field(default="oauth")
+    kind: str = field(default="foundry")
     endpoint: str = field(default="")
-    clientId: str = field(default="")
-    clientSecret: str = field(default="")
-    tokenUrl: str = field(default="")
-    scopes: list[str] = field(default_factory=list)
+    name: str | None = None
+    connection_type: str | None = None
 
     @staticmethod
-    def load(data: Any, context: LoadContext | None = None) -> "OAuthConnection":
-        """Load a OAuthConnection instance.
+    def load(data: Any, context: LoadContext | None = None) -> "FoundryConnection":
+        """Load a FoundryConnection instance.
         Args:
             data (Any): The data to load the instance from.
             context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
         Returns:
-            OAuthConnection: The loaded OAuthConnection instance.
+            FoundryConnection: The loaded FoundryConnection instance.
 
         """
 
@@ -685,29 +688,25 @@ def load(data: Any, context: LoadContext | None = None) -> "OAuthConnection":
             data = context.process_input(data)
 
         if not isinstance(data, dict):
-            raise ValueError(f"Invalid data for OAuthConnection: {data}")
+            raise ValueError(f"Invalid data for FoundryConnection: {data}")
 
         # create new instance
-        instance = OAuthConnection()
+        instance = FoundryConnection()
 
         if data is not None and "kind" in data:
             instance.kind = data["kind"]
         if data is not None and "endpoint" in data:
             instance.endpoint = data["endpoint"]
-        if data is not None and "clientId" in data:
-            instance.clientId = data["clientId"]
-        if data is not None and "clientSecret" in data:
-            instance.clientSecret = data["clientSecret"]
-        if data is not None and "tokenUrl" in data:
-            instance.tokenUrl = data["tokenUrl"]
-        if data is not None and "scopes" in data:
-            instance.scopes = data["scopes"]
+        if data is not None and "name" in data:
+            instance.name = data["name"]
+        if data is not None and "connectionType" in data:
+            instance.connection_type = data["connectionType"]
         if context is not None:
             instance = context.process_output(instance)
         return instance
 
     def save(self, context: SaveContext | None = None) -> dict[str, Any]:
-        """Save the OAuthConnection instance to a dictionary.
+        """Save the FoundryConnection instance to a dictionary.
         Args:
             context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
         Returns:
@@ -725,19 +724,14 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["kind"] = obj.kind
         if obj.endpoint is not None:
             result["endpoint"] = obj.endpoint
-        if obj.clientId is not None:
-            result["clientId"] = obj.clientId
-        if obj.clientSecret is not None:
-            result["clientSecret"] = obj.clientSecret
-        if obj.tokenUrl is not None:
-            result["tokenUrl"] = obj.tokenUrl
-        if obj.scopes is not None:
-            result["scopes"] = obj.scopes
-
+        if obj.name is not None:
+            result["name"] = obj.name
+        if obj.connection_type is not None:
+            result["connectionType"] = obj.connection_type
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
-        """Convert the OAuthConnection instance to a YAML string.
+        """Convert the FoundryConnection instance to a YAML string.
         Args:
             context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
         Returns:
@@ -749,7 +743,7 @@ def to_yaml(self, context: SaveContext | None = None) -> str:
         return context.to_yaml(self.save(context))
 
     def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
-        """Convert the OAuthConnection instance to a JSON string.
+        """Convert the FoundryConnection instance to a JSON string.
         Args:
             context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
             indent (int): Number of spaces for indentation. Defaults to 2.
diff --git a/runtime/python/prompty/prompty/model/_ContentPart.py b/runtime/python/prompty/prompty/model/_ContentPart.py
new file mode 100644
index 00000000..19ebd7f4
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ContentPart.py
@@ -0,0 +1,514 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from abc import ABC
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class ContentPart(ABC):
+    """A part of a message's content. Content parts are discriminated on the `kind`
+    field and represent the different modalities that can appear in a message.
+
+    Attributes
+    ----------
+    kind : str
+        The kind of content part
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ContentPart":
+        """Load a ContentPart instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ContentPart: The loaded ContentPart instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ContentPart: {data}")
+
+        # load polymorphic ContentPart instance
+        instance = ContentPart.load_kind(data, context)
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    @staticmethod
+    def load_kind(data: dict, context: LoadContext | None) -> "ContentPart":
+        # load polymorphic ContentPart instance
+        if data is not None and "kind" in data:
+            discriminator_value = str(data["kind"]).lower()
+            if discriminator_value == "text":
+                return TextPart.load(data, context)
+            elif discriminator_value == "image":
+                return ImagePart.load(data, context)
+            elif discriminator_value == "file":
+                return FilePart.load(data, context)
+            elif discriminator_value == "audio":
+                return AudioPart.load(data, context)
+
+            else:
+                raise ValueError(f"Unknown ContentPart discriminator value: {discriminator_value}")
+        else:
+            raise ValueError("Missing ContentPart discriminator property: 'kind'")
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ContentPart instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ContentPart instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ContentPart instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+
+@dataclass
+class TextPart(ContentPart):
+    """A text content part.
+
+    Attributes
+    ----------
+    kind : str
+        The kind identifier for text content
+    value : str
+        The text content
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="text")
+    value: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "TextPart":
+        """Load a TextPart instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            TextPart: The loaded TextPart instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for TextPart: {data}")
+
+        # create new instance
+        instance = TextPart()
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if data is not None and "value" in data:
+            instance.value = data["value"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the TextPart instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        # Start with parent class properties
+        result = super().save(context)
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+        if obj.value is not None:
+            result["value"] = obj.value
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the TextPart instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the TextPart instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+
+@dataclass
+class ImagePart(ContentPart):
+    """An image content part. The source may be a URL or base64-encoded data.
+
+    Attributes
+    ----------
+    kind : str
+        The kind identifier for image content
+    source : str
+        URL or base64-encoded image data
+    detail : Optional[str]
+        Detail level hint for the model (e.g., 'auto', 'low', 'high')
+    media_type : Optional[str]
+        MIME type of the image (e.g., 'image/png')
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="image")
+    source: str = field(default="")
+    detail: str | None = None
+    media_type: str | None = None
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ImagePart":
+        """Load a ImagePart instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ImagePart: The loaded ImagePart instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ImagePart: {data}")
+
+        # create new instance
+        instance = ImagePart()
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if data is not None and "source" in data:
+            instance.source = data["source"]
+        if data is not None and "detail" in data:
+            instance.detail = data["detail"]
+        if data is not None and "mediaType" in data:
+            instance.media_type = data["mediaType"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ImagePart instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        # Start with parent class properties
+        result = super().save(context)
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+        if obj.source is not None:
+            result["source"] = obj.source
+        if obj.detail is not None:
+            result["detail"] = obj.detail
+        if obj.media_type is not None:
+            result["mediaType"] = obj.media_type
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ImagePart instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ImagePart instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+
+@dataclass
+class FilePart(ContentPart):
+    """A file content part. The source may be a URL or base64-encoded data.
+
+    Attributes
+    ----------
+    kind : str
+        The kind identifier for file content
+    source : str
+        URL or base64-encoded file data
+    media_type : Optional[str]
+        MIME type of the file (e.g., 'application/pdf')
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="file")
+    source: str = field(default="")
+    media_type: str | None = None
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "FilePart":
+        """Load a FilePart instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            FilePart: The loaded FilePart instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for FilePart: {data}")
+
+        # create new instance
+        instance = FilePart()
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if data is not None and "source" in data:
+            instance.source = data["source"]
+        if data is not None and "mediaType" in data:
+            instance.media_type = data["mediaType"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the FilePart instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        # Start with parent class properties
+        result = super().save(context)
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+        if obj.source is not None:
+            result["source"] = obj.source
+        if obj.media_type is not None:
+            result["mediaType"] = obj.media_type
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the FilePart instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the FilePart instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+
+@dataclass
+class AudioPart(ContentPart):
+    """An audio content part. The source may be a URL or base64-encoded data.
+
+    Attributes
+    ----------
+    kind : str
+        The kind identifier for audio content
+    source : str
+        URL or base64-encoded audio data
+    media_type : Optional[str]
+        MIME type of the audio (e.g., 'audio/wav')
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="audio")
+    source: str = field(default="")
+    media_type: str | None = None
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "AudioPart":
+        """Load a AudioPart instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            AudioPart: The loaded AudioPart instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for AudioPart: {data}")
+
+        # create new instance
+        instance = AudioPart()
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if data is not None and "source" in data:
+            instance.source = data["source"]
+        if data is not None and "mediaType" in data:
+            instance.media_type = data["mediaType"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the AudioPart instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        # Start with parent class properties
+        result = super().save(context)
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+        if obj.source is not None:
+            result["source"] = obj.source
+        if obj.media_type is not None:
+            result["mediaType"] = obj.media_type
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the AudioPart instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the AudioPart instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_DoneEventPayload.py b/runtime/python/prompty/prompty/model/_DoneEventPayload.py
new file mode 100644
index 00000000..bb5dce79
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_DoneEventPayload.py
@@ -0,0 +1,128 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+from ._Message import Message
+
+
+@dataclass
+class DoneEventPayload:
+    """Payload for "done" events — the agent loop completed successfully.
+
+    Attributes
+    ----------
+    response : str
+        The final text response from the LLM
+    messages : list[Message]
+        The final conversation state including all messages
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    response: str = field(default="")
+    messages: list[Message] = field(default_factory=list)
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "DoneEventPayload":
+        """Load a DoneEventPayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            DoneEventPayload: The loaded DoneEventPayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for DoneEventPayload: {data}")
+
+        # create new instance
+        instance = DoneEventPayload()
+
+        if data is not None and "response" in data:
+            instance.response = data["response"]
+        if data is not None and "messages" in data:
+            instance.messages = DoneEventPayload.load_messages(data["messages"], context)
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    @staticmethod
+    def load_messages(data: dict | list, context: LoadContext | None) -> list[Message]:
+        if isinstance(data, dict):
+            # convert simple named messages to list of Message
+            result = []
+            for k, v in data.items():
+                if isinstance(v, dict):
+                    # value is an object, spread its properties
+                    result.append({"name": k, **v})
+                else:
+                    # value is a scalar, use it as the primary property
+                    result.append({"name": k, "role": v})
+            data = result
+        return [Message.load(item, context) for item in data]
+
+    @staticmethod
+    def save_messages(items: list[Message], context: SaveContext | None) -> dict[str, Any] | list[dict[str, Any]]:
+        if context is None:
+            context = SaveContext()
+
+        # This type doesn't have a 'name' property, so always use array format
+        return [item.save(context) for item in items]
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the DoneEventPayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.response is not None:
+            result["response"] = obj.response
+        if obj.messages is not None:
+            result["messages"] = DoneEventPayload.save_messages(obj.messages, context)
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the DoneEventPayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the DoneEventPayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_ErrorEventPayload.py b/runtime/python/prompty/prompty/model/_ErrorEventPayload.py
new file mode 100644
index 00000000..75fb522b
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ErrorEventPayload.py
@@ -0,0 +1,97 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class ErrorEventPayload:
+    """Payload for "error" events — an error occurred during the loop.
+
+    Attributes
+    ----------
+    message : str
+        Human-readable error description
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    message: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ErrorEventPayload":
+        """Load a ErrorEventPayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ErrorEventPayload: The loaded ErrorEventPayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ErrorEventPayload: {data}")
+
+        # create new instance
+        instance = ErrorEventPayload()
+
+        if data is not None and "message" in data:
+            instance.message = data["message"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ErrorEventPayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.message is not None:
+            result["message"] = obj.message
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ErrorEventPayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ErrorEventPayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_Executor.py b/runtime/python/prompty/prompty/model/_Executor.py
new file mode 100644
index 00000000..a9de64c6
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_Executor.py
@@ -0,0 +1,38 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from typing import Any, Protocol, runtime_checkable
+
+from ._Message import Message
+from ._Prompty import Prompty
+from ._ToolCall import ToolCall
+
+
+@runtime_checkable
+class Executor(Protocol):
+    """Calls an LLM provider with messages and returns the raw provider response."""
+
+    def execute(self, agent: Prompty, messages: list[Message]) -> Any:
+        """Call an LLM provider with messages and return the raw response"""
+        ...
+
+    async def execute_async(self, agent: Prompty, messages: list[Message]) -> Any:
+        """Call an LLM provider with messages and return the raw response (async variant)"""
+        ...
+
+    def execute_stream(self, agent: Prompty, messages: list[Message]) -> Any:
+        """Call an LLM provider and return a streaming response. Returns a language-specific async iterable/stream of raw chunks. Not all providers support streaming; the default implementation should signal lack of support."""
+        return None
+
+    async def execute_stream_async(self, agent: Prompty, messages: list[Message]) -> Any:
+        """Call an LLM provider and return a streaming response. Returns a language-specific async iterable/stream of raw chunks. Not all providers support streaming; the default implementation should signal lack of support. (async variant)"""
+        return None
+
+    def format_tool_messages(
+        self, raw_response: Any, tool_calls: list[ToolCall], tool_results: list[str], text_content: str | None
+    ) -> list[Message]:
+        """Format tool call results into messages for the next iteration"""
+        ...
diff --git a/runtime/python/prompty/prompty/model/_FormatConfig.py b/runtime/python/prompty/prompty/model/_FormatConfig.py
index ace13c23..23d340ab 100644
--- a/runtime/python/prompty/prompty/model/_FormatConfig.py
+++ b/runtime/python/prompty/prompty/model/_FormatConfig.py
@@ -46,7 +46,11 @@ def load(data: Any, context: LoadContext | None = None) -> "FormatConfig":
 
         # handle alternate representations
         if isinstance(data, str):
-            data = {"kind": data}
+            instance = FormatConfig()
+            instance.kind = data
+            if context is not None:
+                instance = context.process_output(instance)
+            return instance
 
         if not isinstance(data, dict):
             raise ValueError(f"Invalid data for FormatConfig: {data}")
diff --git a/runtime/python/prompty/prompty/model/_GuardrailResult.py b/runtime/python/prompty/prompty/model/_GuardrailResult.py
new file mode 100644
index 00000000..843c0b15
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_GuardrailResult.py
@@ -0,0 +1,128 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class GuardrailResult:
+    """The result of a guardrail evaluation. Guardrails are safety checks that
+    run at specific phases of the agent loop and can allow, deny, or rewrite
+    content.
+
+    Attributes
+    ----------
+    allowed : bool
+        Whether the content passed the guardrail check
+    reason : Optional[str]
+        Explanation of why the content was allowed or denied
+    rewrite : Optional[Any]
+        Optional rewritten content to replace the original
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    allowed: bool = field(default=False)
+    reason: str | None = None
+    rewrite: Any | None = None
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "GuardrailResult":
+        """Load a GuardrailResult instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            GuardrailResult: The loaded GuardrailResult instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for GuardrailResult: {data}")
+
+        # create new instance
+        instance = GuardrailResult()
+
+        if data is not None and "allowed" in data:
+            instance.allowed = data["allowed"]
+        if data is not None and "reason" in data:
+            instance.reason = data["reason"]
+        if data is not None and "rewrite" in data:
+            instance.rewrite = data["rewrite"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the GuardrailResult instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.allowed is not None:
+            result["allowed"] = obj.allowed
+        if obj.reason is not None:
+            result["reason"] = obj.reason
+        if obj.rewrite is not None:
+            result["rewrite"] = obj.rewrite
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the GuardrailResult instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the GuardrailResult instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+    @classmethod
+    def create_rewrite(cls, rewrite: Any) -> "GuardrailResult":
+        """Create a GuardrailResult with preset field values."""
+        return GuardrailResult(allowed=True, rewrite=rewrite)
+
+    @classmethod
+    def deny(cls, reason: str) -> "GuardrailResult":
+        """Create a GuardrailResult with preset field values."""
+        return GuardrailResult(allowed=False, reason=reason)
+
+    @classmethod
+    def allow(cls) -> "GuardrailResult":
+        """Create a GuardrailResult with preset field values."""
+        return GuardrailResult(allowed=True)
diff --git a/runtime/python/prompty/prompty/model/_McpApprovalMode.py b/runtime/python/prompty/prompty/model/_McpApprovalMode.py
index 52fd9b34..b4d9a126 100644
--- a/runtime/python/prompty/prompty/model/_McpApprovalMode.py
+++ b/runtime/python/prompty/prompty/model/_McpApprovalMode.py
@@ -20,17 +20,17 @@ class McpApprovalMode:
     ----------
     kind : str
         The approval mode: 'always', 'never', or 'specify'
-    alwaysRequireApprovalTools : list[str]
+    always_require_approval_tools : Optional[list[str]]
         List of tools that always require approval (only used when kind is 'specify')
-    neverRequireApprovalTools : list[str]
+    never_require_approval_tools : Optional[list[str]]
         List of tools that never require approval (only used when kind is 'specify')
     """
 
     _shorthand_property: ClassVar[str | None] = "kind"
 
     kind: str = field(default="")
-    alwaysRequireApprovalTools: list[str] = field(default_factory=list)
-    neverRequireApprovalTools: list[str] = field(default_factory=list)
+    always_require_approval_tools: list[str] = field(default_factory=list)
+    never_require_approval_tools: list[str] = field(default_factory=list)
 
     @staticmethod
     def load(data: Any, context: LoadContext | None = None) -> "McpApprovalMode":
@@ -48,7 +48,11 @@ def load(data: Any, context: LoadContext | None = None) -> "McpApprovalMode":
 
         # handle alternate representations
         if isinstance(data, str):
-            data = {"kind": data}
+            instance = McpApprovalMode()
+            instance.kind = data
+            if context is not None:
+                instance = context.process_output(instance)
+            return instance
 
         if not isinstance(data, dict):
             raise ValueError(f"Invalid data for McpApprovalMode: {data}")
@@ -59,9 +63,9 @@ def load(data: Any, context: LoadContext | None = None) -> "McpApprovalMode":
         if data is not None and "kind" in data:
             instance.kind = data["kind"]
         if data is not None and "alwaysRequireApprovalTools" in data:
-            instance.alwaysRequireApprovalTools = data["alwaysRequireApprovalTools"]
+            instance.always_require_approval_tools = data["alwaysRequireApprovalTools"]
         if data is not None and "neverRequireApprovalTools" in data:
-            instance.neverRequireApprovalTools = data["neverRequireApprovalTools"]
+            instance.never_require_approval_tools = data["neverRequireApprovalTools"]
         if context is not None:
             instance = context.process_output(instance)
         return instance
@@ -82,10 +86,10 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
 
         if obj.kind is not None:
             result["kind"] = obj.kind
-        if obj.alwaysRequireApprovalTools is not None:
-            result["alwaysRequireApprovalTools"] = obj.alwaysRequireApprovalTools
-        if obj.neverRequireApprovalTools is not None:
-            result["neverRequireApprovalTools"] = obj.neverRequireApprovalTools
+        if obj.always_require_approval_tools is not None:
+            result["alwaysRequireApprovalTools"] = obj.always_require_approval_tools
+        if obj.never_require_approval_tools is not None:
+            result["neverRequireApprovalTools"] = obj.never_require_approval_tools
 
         if context is not None:
             result = context.process_dict(result)
diff --git a/runtime/python/prompty/prompty/model/_Message.py b/runtime/python/prompty/prompty/model/_Message.py
new file mode 100644
index 00000000..7b66afef
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_Message.py
@@ -0,0 +1,171 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar, Protocol, runtime_checkable
+
+from ._ContentPart import ContentPart, TextPart
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class Message:
+    """A message in a conversation. Messages have a role and a list of content parts
+    representing the different modalities of the message content.
+
+    Attributes
+    ----------
+    role : str
+        The role of the message sender
+    parts : list[ContentPart]
+        The content parts of the message
+    metadata : dict[str, Any]
+        Optional metadata associated with the message
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    role: str = field(default="user")
+    parts: list[ContentPart] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "Message":
+        """Load a Message instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            Message: The loaded Message instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for Message: {data}")
+
+        # create new instance
+        instance = Message()
+
+        if data is not None and "role" in data:
+            instance.role = data["role"]
+        if data is not None and "parts" in data:
+            instance.parts = Message.load_parts(data["parts"], context)
+        if data is not None and "metadata" in data:
+            instance.metadata = data["metadata"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    @staticmethod
+    def load_parts(data: dict | list, context: LoadContext | None) -> list[ContentPart]:
+        if isinstance(data, dict):
+            # convert simple named parts to list of ContentPart
+            result = []
+            for k, v in data.items():
+                if isinstance(v, dict):
+                    # value is an object, spread its properties
+                    result.append({"name": k, **v})
+                else:
+                    # value is a scalar, use it as the primary property
+                    result.append({"name": k, "kind": v})
+            data = result
+        return [ContentPart.load(item, context) for item in data]
+
+    @staticmethod
+    def save_parts(items: list[ContentPart], context: SaveContext | None) -> dict[str, Any] | list[dict[str, Any]]:
+        if context is None:
+            context = SaveContext()
+
+        # This type doesn't have a 'name' property, so always use array format
+        return [item.save(context) for item in items]
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the Message instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.role is not None:
+            result["role"] = obj.role
+        if obj.parts is not None:
+            result["parts"] = Message.save_parts(obj.parts, context)
+        if obj.metadata is not None:
+            result["metadata"] = obj.metadata
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the Message instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the Message instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+    @classmethod
+    def assistant(cls, text: str) -> "Message":
+        """Create a Message with preset field values."""
+        return Message(role="assistant", parts=[TextPart(value=text)])
+
+    @classmethod
+    def system(cls, text: str) -> "Message":
+        """Create a Message with preset field values."""
+        return Message(role="system", parts=[TextPart(value=text)])
+
+    @classmethod
+    def user(cls, text: str) -> "Message":
+        """Create a Message with preset field values."""
+        return Message(role="user", parts=[TextPart(value=text)])
+
+
+@runtime_checkable
+class MessageHelpers(Protocol):
+    """Helper contract for Message.
+
+    Runtime implementations must provide these methods on every Message
+    instance (either by attaching them to the generated class or by wrapping it).
+    The type checker can verify conformance by annotating against this Protocol
+    or by calling isinstance(instance, MessageHelpers) at runtime.
+    """
+
+    def to_text_content(self) -> Any:
+        """Return plain string if all parts are text, else a list of content part dicts for wire serialization"""
+        ...
+
+    @property
+    def text(self) -> str:
+        """Concatenate all TextPart values joined by newline"""
+        ...
diff --git a/runtime/python/prompty/prompty/model/_MessagesUpdatedPayload.py b/runtime/python/prompty/prompty/model/_MessagesUpdatedPayload.py
new file mode 100644
index 00000000..cec2c32a
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_MessagesUpdatedPayload.py
@@ -0,0 +1,121 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+from ._Message import Message
+
+
+@dataclass
+class MessagesUpdatedPayload:
+    """Payload for "messages_updated" events — the conversation state has changed.
+
+    Attributes
+    ----------
+    messages : list[Message]
+        The current full message list after the update
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    messages: list[Message] = field(default_factory=list)
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "MessagesUpdatedPayload":
+        """Load a MessagesUpdatedPayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            MessagesUpdatedPayload: The loaded MessagesUpdatedPayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for MessagesUpdatedPayload: {data}")
+
+        # create new instance
+        instance = MessagesUpdatedPayload()
+
+        if data is not None and "messages" in data:
+            instance.messages = MessagesUpdatedPayload.load_messages(data["messages"], context)
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    @staticmethod
+    def load_messages(data: dict | list, context: LoadContext | None) -> list[Message]:
+        if isinstance(data, dict):
+            # convert simple named messages to list of Message
+            result = []
+            for k, v in data.items():
+                if isinstance(v, dict):
+                    # value is an object, spread its properties
+                    result.append({"name": k, **v})
+                else:
+                    # value is a scalar, use it as the primary property
+                    result.append({"name": k, "role": v})
+            data = result
+        return [Message.load(item, context) for item in data]
+
+    @staticmethod
+    def save_messages(items: list[Message], context: SaveContext | None) -> dict[str, Any] | list[dict[str, Any]]:
+        if context is None:
+            context = SaveContext()
+
+        # This type doesn't have a 'name' property, so always use array format
+        return [item.save(context) for item in items]
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the MessagesUpdatedPayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.messages is not None:
+            result["messages"] = MessagesUpdatedPayload.save_messages(obj.messages, context)
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the MessagesUpdatedPayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the MessagesUpdatedPayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_Model.py b/runtime/python/prompty/prompty/model/_Model.py
index d1f57eef..23bda843 100644
--- a/runtime/python/prompty/prompty/model/_Model.py
+++ b/runtime/python/prompty/prompty/model/_Model.py
@@ -24,7 +24,7 @@ class Model:
         The unique identifier of the model - can be used as the single property shorthand
     provider : Optional[str]
         The provider of the model (e.g., 'openai', 'foundry', 'anthropic')
-    apiType : Optional[str]
+    api_type : Optional[str]
         The type of API to use for the model (e.g., 'chat', 'response', etc.)
     connection : Optional[Connection]
         The connection configuration for the model
@@ -36,7 +36,7 @@ class Model:
 
     id: str = field(default="")
     provider: str | None = None
-    apiType: str | None = None
+    api_type: str | None = None
     connection: Connection | None = None
     options: ModelOptions | None = None
 
@@ -56,7 +56,11 @@ def load(data: Any, context: LoadContext | None = None) -> "Model":
 
         # handle alternate representations
         if isinstance(data, str):
-            data = {"id": data}
+            instance = Model()
+            instance.id = data
+            if context is not None:
+                instance = context.process_output(instance)
+            return instance
 
         if not isinstance(data, dict):
             raise ValueError(f"Invalid data for Model: {data}")
@@ -69,7 +73,7 @@ def load(data: Any, context: LoadContext | None = None) -> "Model":
         if data is not None and "provider" in data:
             instance.provider = data["provider"]
         if data is not None and "apiType" in data:
-            instance.apiType = data["apiType"]
+            instance.api_type = data["apiType"]
         if data is not None and "connection" in data:
             instance.connection = Connection.load(data["connection"], context)
         if data is not None and "options" in data:
@@ -96,8 +100,8 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["id"] = obj.id
         if obj.provider is not None:
             result["provider"] = obj.provider
-        if obj.apiType is not None:
-            result["apiType"] = obj.apiType
+        if obj.api_type is not None:
+            result["apiType"] = obj.api_type
         if obj.connection is not None:
             result["connection"] = obj.connection.save(context)
         if obj.options is not None:
diff --git a/runtime/python/prompty/prompty/model/_ModelInfo.py b/runtime/python/prompty/prompty/model/_ModelInfo.py
new file mode 100644
index 00000000..9f03270b
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ModelInfo.py
@@ -0,0 +1,144 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class ModelInfo:
+    """Information about a model available from a provider. Used by provider-level
+    model discovery to report which models are available and their capabilities.
+
+    Not all providers return all fields — implementations SHOULD populate as
+    many fields as the provider's API supports and MAY enrich sparse results
+    from a built-in lookup table of known models.
+
+    Attributes
+    ----------
+    id : str
+        The model identifier (e.g., 'gpt-4o', 'claude-3-opus')
+    display_name : Optional[str]
+        Human-readable display name
+    owned_by : Optional[str]
+        The organization or entity that owns the model
+    context_window : Optional[int]
+        Maximum context window size in tokens
+    input_modalities : Optional[list[str]]
+        Input modalities the model accepts (e.g., 'text', 'image', 'audio')
+    output_modalities : Optional[list[str]]
+        Output modalities the model can produce (e.g., 'text', 'audio')
+    additional_properties : Optional[dict[str, Any]]
+        Additional provider-specific properties
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    id: str = field(default="")
+    display_name: str | None = None
+    owned_by: str | None = None
+    context_window: int | None = None
+    input_modalities: list[str] = field(default_factory=list)
+    output_modalities: list[str] = field(default_factory=list)
+    additional_properties: dict[str, Any] | None = None
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ModelInfo":
+        """Load a ModelInfo instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ModelInfo: The loaded ModelInfo instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ModelInfo: {data}")
+
+        # create new instance
+        instance = ModelInfo()
+
+        if data is not None and "id" in data:
+            instance.id = data["id"]
+        if data is not None and "displayName" in data:
+            instance.display_name = data["displayName"]
+        if data is not None and "ownedBy" in data:
+            instance.owned_by = data["ownedBy"]
+        if data is not None and "contextWindow" in data:
+            instance.context_window = data["contextWindow"]
+        if data is not None and "inputModalities" in data:
+            instance.input_modalities = data["inputModalities"]
+        if data is not None and "outputModalities" in data:
+            instance.output_modalities = data["outputModalities"]
+        if data is not None and "additionalProperties" in data:
+            instance.additional_properties = data["additionalProperties"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ModelInfo instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.id is not None:
+            result["id"] = obj.id
+        if obj.display_name is not None:
+            result["displayName"] = obj.display_name
+        if obj.owned_by is not None:
+            result["ownedBy"] = obj.owned_by
+        if obj.context_window is not None:
+            result["contextWindow"] = obj.context_window
+        if obj.input_modalities is not None:
+            result["inputModalities"] = obj.input_modalities
+        if obj.output_modalities is not None:
+            result["outputModalities"] = obj.output_modalities
+        if obj.additional_properties is not None:
+            result["additionalProperties"] = obj.additional_properties
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ModelInfo instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ModelInfo instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_ModelOptions.py b/runtime/python/prompty/prompty/model/_ModelOptions.py
index c1c23fbf..9fdd9329 100644
--- a/runtime/python/prompty/prompty/model/_ModelOptions.py
+++ b/runtime/python/prompty/prompty/model/_ModelOptions.py
@@ -16,40 +16,40 @@ class ModelOptions:
 
     Attributes
     ----------
-    frequencyPenalty : Optional[float]
+    frequency_penalty : Optional[float]
         The frequency penalty to apply to the model's output
-    maxOutputTokens : Optional[int]
+    max_output_tokens : Optional[int]
         The maximum number of tokens to generate in the output
-    presencePenalty : Optional[float]
+    presence_penalty : Optional[float]
         The presence penalty to apply to the model's output
     seed : Optional[int]
         A random seed for deterministic output
     temperature : Optional[float]
         The temperature to use for sampling
-    topK : Optional[int]
+    top_k : Optional[int]
         The top-K sampling value
-    topP : Optional[float]
+    top_p : Optional[float]
         The top-P sampling value
-    stopSequences : list[str]
+    stop_sequences : Optional[list[str]]
         Stop sequences to end generation
-    allowMultipleToolCalls : Optional[bool]
+    allow_multiple_tool_calls : Optional[bool]
         Whether to allow multiple tool calls in a single response
-    additionalProperties : Optional[dict[str, Any]]
+    additional_properties : Optional[dict[str, Any]]
         Additional custom properties for model options
     """
 
     _shorthand_property: ClassVar[str | None] = None
 
-    frequencyPenalty: float | None = None
-    maxOutputTokens: int | None = None
-    presencePenalty: float | None = None
+    frequency_penalty: float | None = None
+    max_output_tokens: int | None = None
+    presence_penalty: float | None = None
     seed: int | None = None
     temperature: float | None = None
-    topK: int | None = None
-    topP: float | None = None
-    stopSequences: list[str] = field(default_factory=list)
-    allowMultipleToolCalls: bool | None = None
-    additionalProperties: dict[str, Any] | None = None
+    top_k: int | None = None
+    top_p: float | None = None
+    stop_sequences: list[str] = field(default_factory=list)
+    allow_multiple_tool_calls: bool | None = None
+    additional_properties: dict[str, Any] | None = None
 
     @staticmethod
     def load(data: Any, context: LoadContext | None = None) -> "ModelOptions":
@@ -72,25 +72,25 @@ def load(data: Any, context: LoadContext | None = None) -> "ModelOptions":
         instance = ModelOptions()
 
         if data is not None and "frequencyPenalty" in data:
-            instance.frequencyPenalty = data["frequencyPenalty"]
+            instance.frequency_penalty = data["frequencyPenalty"]
         if data is not None and "maxOutputTokens" in data:
-            instance.maxOutputTokens = data["maxOutputTokens"]
+            instance.max_output_tokens = data["maxOutputTokens"]
         if data is not None and "presencePenalty" in data:
-            instance.presencePenalty = data["presencePenalty"]
+            instance.presence_penalty = data["presencePenalty"]
         if data is not None and "seed" in data:
             instance.seed = data["seed"]
         if data is not None and "temperature" in data:
             instance.temperature = data["temperature"]
         if data is not None and "topK" in data:
-            instance.topK = data["topK"]
+            instance.top_k = data["topK"]
         if data is not None and "topP" in data:
-            instance.topP = data["topP"]
+            instance.top_p = data["topP"]
         if data is not None and "stopSequences" in data:
-            instance.stopSequences = data["stopSequences"]
+            instance.stop_sequences = data["stopSequences"]
         if data is not None and "allowMultipleToolCalls" in data:
-            instance.allowMultipleToolCalls = data["allowMultipleToolCalls"]
+            instance.allow_multiple_tool_calls = data["allowMultipleToolCalls"]
         if data is not None and "additionalProperties" in data:
-            instance.additionalProperties = data["additionalProperties"]
+            instance.additional_properties = data["additionalProperties"]
         if context is not None:
             instance = context.process_output(instance)
         return instance
@@ -109,31 +109,62 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
 
         result: dict[str, Any] = {}
 
-        if obj.frequencyPenalty is not None:
-            result["frequencyPenalty"] = obj.frequencyPenalty
-        if obj.maxOutputTokens is not None:
-            result["maxOutputTokens"] = obj.maxOutputTokens
-        if obj.presencePenalty is not None:
-            result["presencePenalty"] = obj.presencePenalty
+        if obj.frequency_penalty is not None:
+            result["frequencyPenalty"] = obj.frequency_penalty
+        if obj.max_output_tokens is not None:
+            result["maxOutputTokens"] = obj.max_output_tokens
+        if obj.presence_penalty is not None:
+            result["presencePenalty"] = obj.presence_penalty
         if obj.seed is not None:
             result["seed"] = obj.seed
         if obj.temperature is not None:
             result["temperature"] = obj.temperature
-        if obj.topK is not None:
-            result["topK"] = obj.topK
-        if obj.topP is not None:
-            result["topP"] = obj.topP
-        if obj.stopSequences is not None:
-            result["stopSequences"] = obj.stopSequences
-        if obj.allowMultipleToolCalls is not None:
-            result["allowMultipleToolCalls"] = obj.allowMultipleToolCalls
-        if obj.additionalProperties is not None:
-            result["additionalProperties"] = obj.additionalProperties
+        if obj.top_k is not None:
+            result["topK"] = obj.top_k
+        if obj.top_p is not None:
+            result["topP"] = obj.top_p
+        if obj.stop_sequences is not None:
+            result["stopSequences"] = obj.stop_sequences
+        if obj.allow_multiple_tool_calls is not None:
+            result["allowMultipleToolCalls"] = obj.allow_multiple_tool_calls
+        if obj.additional_properties is not None:
+            result["additionalProperties"] = obj.additional_properties
 
         if context is not None:
             result = context.process_dict(result)
         return result
 
+    def to_wire(self, provider: str) -> dict[str, Any]:
+        """Convert to provider-specific wire format.
+        Args:
+            provider (str): The provider to convert to (e.g., "openai", "anthropic").
+        Returns:
+            dict[str, Any]: The wire-format dictionary with provider-specific field names.
+
+        """
+        data = self.save()
+        result: dict[str, Any] = {}
+        wire_map: dict[str, dict[str, str]] = {
+            "frequencyPenalty": {"openai": "frequency_penalty"},
+            "maxOutputTokens": {
+                "openai": "max_completion_tokens",
+                "responses": "max_output_tokens",
+                "anthropic": "max_tokens",
+            },
+            "presencePenalty": {"openai": "presence_penalty"},
+            "seed": {"openai": "seed"},
+            "temperature": {"openai": "temperature", "responses": "temperature", "anthropic": "temperature"},
+            "topK": {"openai": "top_k", "anthropic": "top_k"},
+            "topP": {"openai": "top_p", "responses": "top_p", "anthropic": "top_p"},
+            "stopSequences": {"openai": "stop", "anthropic": "stop_sequences"},
+            "allowMultipleToolCalls": {"openai": "parallel_tool_calls"},
+        }
+        for key, value in data.items():
+            mapping = wire_map.get(key)
+            if mapping is not None and provider in mapping:
+                result[mapping[provider]] = value
+        return result
+
     def to_yaml(self, context: SaveContext | None = None) -> str:
         """Convert the ModelOptions instance to a YAML string.
         Args:
diff --git a/runtime/python/prompty/prompty/model/_Parser.py b/runtime/python/prompty/prompty/model/_Parser.py
new file mode 100644
index 00000000..89df350a
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_Parser.py
@@ -0,0 +1,27 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from typing import Any, Protocol, runtime_checkable
+
+from ._Message import Message
+from ._Prompty import Prompty
+
+
+@runtime_checkable
+class Parser(Protocol):
+    """Parses rendered prompt text into an array of structured messages with role markers."""
+
+    def pre_render(self, template: str) -> Any | None:
+        """Pre-process a template before rendering, returning modified template and context"""
+        return None
+
+    def parse(self, agent: Prompty, rendered: str, context: dict[str, Any] | None) -> list[Message]:
+        """Parse rendered text into a structured message array"""
+        ...
+
+    async def parse_async(self, agent: Prompty, rendered: str, context: dict[str, Any] | None) -> list[Message]:
+        """Parse rendered text into a structured message array (async variant)"""
+        ...
diff --git a/runtime/python/prompty/prompty/model/_ParserConfig.py b/runtime/python/prompty/prompty/model/_ParserConfig.py
index 47510422..86bdd123 100644
--- a/runtime/python/prompty/prompty/model/_ParserConfig.py
+++ b/runtime/python/prompty/prompty/model/_ParserConfig.py
@@ -43,7 +43,11 @@ def load(data: Any, context: LoadContext | None = None) -> "ParserConfig":
 
         # handle alternate representations
         if isinstance(data, str):
-            data = {"kind": data}
+            instance = ParserConfig()
+            instance.kind = data
+            if context is not None:
+                instance = context.process_output(instance)
+            return instance
 
         if not isinstance(data, dict):
             raise ValueError(f"Invalid data for ParserConfig: {data}")
diff --git a/runtime/python/prompty/prompty/model/_Processor.py b/runtime/python/prompty/prompty/model/_Processor.py
new file mode 100644
index 00000000..a9f39a23
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_Processor.py
@@ -0,0 +1,30 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from typing import Any, Protocol, runtime_checkable
+
+from ._Prompty import Prompty
+
+
+@runtime_checkable
+class Processor(Protocol):
+    """Extracts a clean, typed result from a raw LLM provider response."""
+
+    def process(self, agent: Prompty, response: Any) -> Any:
+        """Extract a clean result from a raw LLM response"""
+        ...
+
+    async def process_async(self, agent: Prompty, response: Any) -> Any:
+        """Extract a clean result from a raw LLM response (async variant)"""
+        ...
+
+    def process_stream(self, stream: Any) -> Any:
+        """Process a streaming response into a stream of StreamChunk items. Takes raw chunks from the executor and yields processed text, thinking, tool, or error chunks. Not all providers support streaming; the default implementation should signal lack of support."""
+        return None
+
+    async def process_stream_async(self, stream: Any) -> Any:
+        """Process a streaming response into a stream of StreamChunk items. Takes raw chunks from the executor and yields processed text, thinking, tool, or error chunks. Not all providers support streaming; the default implementation should signal lack of support. (async variant)"""
+        return None
diff --git a/runtime/python/prompty/prompty/model/_Prompty.py b/runtime/python/prompty/prompty/model/_Prompty.py
index 877db419..8c6b20aa 100644
--- a/runtime/python/prompty/prompty/model/_Prompty.py
+++ b/runtime/python/prompty/prompty/model/_Prompty.py
@@ -27,19 +27,19 @@ class or kind discriminator. A .prompty file always produces a Prompty instance.
     ----------
     name : str
         Human-readable name of the prompt
-    displayName : Optional[str]
+    display_name : Optional[str]
         Display name for UI purposes
     description : Optional[str]
         Description of the prompt's purpose
     metadata : Optional[dict[str, Any]]
         Additional metadata including authors, tags, and other arbitrary properties
-    inputs : list[Property]
+    inputs : Optional[list[Property]]
         Input parameters that participate in template rendering
-    outputs : list[Property]
+    outputs : Optional[list[Property]]
         Expected output format and structure
     model : Model
         AI model configuration
-    tools : list[Tool]
+    tools : Optional[list[Tool]]
         Tools available for extended functionality
     template : Optional[Template]
         Template configuration for prompt rendering
@@ -50,7 +50,7 @@ class or kind discriminator. A .prompty file always produces a Prompty instance.
     _shorthand_property: ClassVar[str | None] = None
 
     name: str = field(default="")
-    displayName: str | None = None
+    display_name: str | None = None
     description: str | None = None
     metadata: dict[str, Any] | None = None
     inputs: list[Property] = field(default_factory=list)
@@ -83,7 +83,7 @@ def load(data: Any, context: LoadContext | None = None) -> "Prompty":
         if data is not None and "name" in data:
             instance.name = data["name"]
         if data is not None and "displayName" in data:
-            instance.displayName = data["displayName"]
+            instance.display_name = data["displayName"]
         if data is not None and "description" in data:
             instance.description = data["description"]
         if data is not None and "metadata" in data:
@@ -158,7 +158,7 @@ def load_outputs(data: dict | list, context: LoadContext | None) -> list[Propert
                     result.append({"name": k, **v})
                 else:
                     # value is a scalar, use it as the primary property
-                    result.append({"name": k, "": v})
+                    result.append({"name": k, "kind": v})
             data = result
         return [Property.load(item, context) for item in data]
 
@@ -167,28 +167,8 @@ def save_outputs(items: list[Property], context: SaveContext | None) -> dict[str
         if context is None:
             context = SaveContext()
 
-        if context.collection_format == "array":
-            return [item.save(context) for item in items]
-
-        # Object format: use name as key
-        result: dict[str, Any] = {}
-        for item in items:
-            item_data = item.save(context)
-            name = item_data.pop("name", None)
-            if name:
-                # Check if we can use shorthand (only primary property set)
-                if context.use_shorthand and hasattr(item, "_shorthand_property"):
-                    shorthand_prop = item._shorthand_property
-                    if shorthand_prop and len(item_data) == 1 and shorthand_prop in item_data:
-                        result[name] = item_data[shorthand_prop]
-                        continue
-                result[name] = item_data
-            else:
-                # No name, fall back to array format for this item
-                if "_unnamed" not in result:
-                    result["_unnamed"] = []
-                result["_unnamed"].append(item_data)
-        return result
+        # This type doesn't have a 'name' property, so always use array format
+        return [item.save(context) for item in items]
 
     @staticmethod
     def load_tools(data: dict | list, context: LoadContext | None) -> list[Tool]:
@@ -249,8 +229,8 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
 
         if obj.name is not None:
             result["name"] = obj.name
-        if obj.displayName is not None:
-            result["displayName"] = obj.displayName
+        if obj.display_name is not None:
+            result["displayName"] = obj.display_name
         if obj.description is not None:
             result["description"] = obj.description
         if obj.metadata is not None:
diff --git a/runtime/python/prompty/prompty/model/_Property.py b/runtime/python/prompty/prompty/model/_Property.py
index 7e2f8270..198e1b2b 100644
--- a/runtime/python/prompty/prompty/model/_Property.py
+++ b/runtime/python/prompty/prompty/model/_Property.py
@@ -33,7 +33,7 @@ class Property:
         The default value of the property - this represents the default value if none is provided
     example : Optional[Any]
         Example value used for either initialization or tooling
-    enumValues : list[Any]
+    enum_values : Optional[list[Any]]
         Allowed enumeration values for the property
     """
 
@@ -45,7 +45,7 @@ class Property:
     required: bool | None = None
     default: Any | None = None
     example: Any | None = None
-    enumValues: list[Any] = field(default_factory=list)
+    enum_values: list[Any] = field(default_factory=list)
 
     @staticmethod
     def load(data: Any, context: LoadContext | None = None) -> "Property":
@@ -63,13 +63,33 @@ def load(data: Any, context: LoadContext | None = None) -> "Property":
 
         # handle alternate representations
         if isinstance(data, bool):
-            data = {"kind": "boolean", "example": data}
+            instance = Property()
+            instance.kind = "boolean"
+            instance.example = data
+            if context is not None:
+                instance = context.process_output(instance)
+            return instance
         if isinstance(data, float):
-            data = {"kind": "float", "example": data}
+            instance = Property()
+            instance.kind = "float"
+            instance.example = data
+            if context is not None:
+                instance = context.process_output(instance)
+            return instance
         if isinstance(data, int):
-            data = {"kind": "integer", "example": data}
+            instance = Property()
+            instance.kind = "integer"
+            instance.example = data
+            if context is not None:
+                instance = context.process_output(instance)
+            return instance
         if isinstance(data, str):
-            data = {"kind": "string", "example": data}
+            instance = Property()
+            instance.kind = "string"
+            instance.example = data
+            if context is not None:
+                instance = context.process_output(instance)
+            return instance
 
         if not isinstance(data, dict):
             raise ValueError(f"Invalid data for Property: {data}")
@@ -90,7 +110,7 @@ def load(data: Any, context: LoadContext | None = None) -> "Property":
         if data is not None and "example" in data:
             instance.example = data["example"]
         if data is not None and "enumValues" in data:
-            instance.enumValues = data["enumValues"]
+            instance.enum_values = data["enumValues"]
         if context is not None:
             instance = context.process_output(instance)
         return instance
@@ -108,7 +128,6 @@ def load_kind(data: dict, context: LoadContext | None) -> "Property":
             else:
                 # create new instance (stop recursion)
                 return Property()
-
         else:
             # create new instance
             return Property()
@@ -139,8 +158,8 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["default"] = obj.default
         if obj.example is not None:
             result["example"] = obj.example
-        if obj.enumValues is not None:
-            result["enumValues"] = obj.enumValues
+        if obj.enum_values is not None:
+            result["enumValues"] = obj.enum_values
 
         if context is not None:
             result = context.process_dict(result)
@@ -237,7 +256,6 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["kind"] = obj.kind
         if obj.items is not None:
             result["items"] = obj.items.save(context)
-
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
@@ -323,7 +341,7 @@ def load_properties(data: dict | list, context: LoadContext | None) -> list[Prop
                     result.append({"name": k, **v})
                 else:
                     # value is a scalar, use it as the primary property
-                    result.append({"name": k, "": v})
+                    result.append({"name": k, "kind": v})
             data = result
         return [Property.load(item, context) for item in data]
 
@@ -332,28 +350,8 @@ def save_properties(items: list[Property], context: SaveContext | None) -> dict[
         if context is None:
             context = SaveContext()
 
-        if context.collection_format == "array":
-            return [item.save(context) for item in items]
-
-        # Object format: use name as key
-        result: dict[str, Any] = {}
-        for item in items:
-            item_data = item.save(context)
-            name = item_data.pop("name", None)
-            if name:
-                # Check if we can use shorthand (only primary property set)
-                if context.use_shorthand and hasattr(item, "_shorthand_property"):
-                    shorthand_prop = item._shorthand_property
-                    if shorthand_prop and len(item_data) == 1 and shorthand_prop in item_data:
-                        result[name] = item_data[shorthand_prop]
-                        continue
-                result[name] = item_data
-            else:
-                # No name, fall back to array format for this item
-                if "_unnamed" not in result:
-                    result["_unnamed"] = []
-                result["_unnamed"].append(item_data)
-        return result
+        # This type doesn't have a 'name' property, so always use array format
+        return [item.save(context) for item in items]
 
     def save(self, context: SaveContext | None = None) -> dict[str, Any]:
         """Save the ObjectProperty instance to a dictionary.
@@ -374,7 +372,6 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["kind"] = obj.kind
         if obj.properties is not None:
             result["properties"] = ObjectProperty.save_properties(obj.properties, context)
-
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
diff --git a/runtime/python/prompty/prompty/model/_Renderer.py b/runtime/python/prompty/prompty/model/_Renderer.py
new file mode 100644
index 00000000..dddbfb3f
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_Renderer.py
@@ -0,0 +1,22 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from typing import Any, Protocol, runtime_checkable
+
+from ._Prompty import Prompty
+
+
+@runtime_checkable
+class Renderer(Protocol):
+    """Renders a template string with input values to produce the final prompt text."""
+
+    def render(self, agent: Prompty, template: str, inputs: dict[str, Any]) -> str:
+        """Render the template string with input values"""
+        ...
+
+    async def render_async(self, agent: Prompty, template: str, inputs: dict[str, Any]) -> str:
+        """Render the template string with input values (async variant)"""
+        ...
diff --git a/runtime/python/prompty/prompty/model/_StatusEventPayload.py b/runtime/python/prompty/prompty/model/_StatusEventPayload.py
new file mode 100644
index 00000000..6c75f91c
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_StatusEventPayload.py
@@ -0,0 +1,97 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class StatusEventPayload:
+    """Payload for "status" events — informational messages about loop progress.
+
+    Attributes
+    ----------
+    message : str
+        Human-readable status message
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    message: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "StatusEventPayload":
+        """Load a StatusEventPayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            StatusEventPayload: The loaded StatusEventPayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for StatusEventPayload: {data}")
+
+        # create new instance
+        instance = StatusEventPayload()
+
+        if data is not None and "message" in data:
+            instance.message = data["message"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the StatusEventPayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.message is not None:
+            result["message"] = obj.message
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the StatusEventPayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the StatusEventPayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_StreamChunk.py b/runtime/python/prompty/prompty/model/_StreamChunk.py
new file mode 100644
index 00000000..db4abc19
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_StreamChunk.py
@@ -0,0 +1,487 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from abc import ABC
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+from ._ToolCall import ToolCall
+
+
+@dataclass
+class StreamChunk(ABC):
+    """A chunk of data from a streaming LLM response. Stream chunks are
+    discriminated on the `kind` field.
+
+    Attributes
+    ----------
+    kind : str
+        The kind of stream chunk
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "StreamChunk":
+        """Load a StreamChunk instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            StreamChunk: The loaded StreamChunk instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for StreamChunk: {data}")
+
+        # load polymorphic StreamChunk instance
+        instance = StreamChunk.load_kind(data, context)
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    @staticmethod
+    def load_kind(data: dict, context: LoadContext | None) -> "StreamChunk":
+        # load polymorphic StreamChunk instance
+        if data is not None and "kind" in data:
+            discriminator_value = str(data["kind"]).lower()
+            if discriminator_value == "text":
+                return TextChunk.load(data, context)
+            elif discriminator_value == "thinking":
+                return ThinkingChunk.load(data, context)
+            elif discriminator_value == "tool":
+                return ToolChunk.load(data, context)
+            elif discriminator_value == "error":
+                return ErrorChunk.load(data, context)
+
+            else:
+                raise ValueError(f"Unknown StreamChunk discriminator value: {discriminator_value}")
+        else:
+            raise ValueError("Missing StreamChunk discriminator property: 'kind'")
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the StreamChunk instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the StreamChunk instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the StreamChunk instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+
+@dataclass
+class TextChunk(StreamChunk):
+    """A text content chunk from the LLM response stream.
+
+    Attributes
+    ----------
+    kind : str
+        The kind identifier for text chunks
+    value : str
+        The text content of the chunk
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="text")
+    value: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "TextChunk":
+        """Load a TextChunk instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            TextChunk: The loaded TextChunk instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for TextChunk: {data}")
+
+        # create new instance
+        instance = TextChunk()
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if data is not None and "value" in data:
+            instance.value = data["value"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the TextChunk instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        # Start with parent class properties
+        result = super().save(context)
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+        if obj.value is not None:
+            result["value"] = obj.value
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the TextChunk instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the TextChunk instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+
+@dataclass
+class ThinkingChunk(StreamChunk):
+    """A thinking/reasoning content chunk from the LLM response stream.
+
+    Attributes
+    ----------
+    kind : str
+        The kind identifier for thinking chunks
+    value : str
+        The thinking content of the chunk
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="thinking")
+    value: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ThinkingChunk":
+        """Load a ThinkingChunk instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ThinkingChunk: The loaded ThinkingChunk instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ThinkingChunk: {data}")
+
+        # create new instance
+        instance = ThinkingChunk()
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if data is not None and "value" in data:
+            instance.value = data["value"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ThinkingChunk instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        # Start with parent class properties
+        result = super().save(context)
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+        if obj.value is not None:
+            result["value"] = obj.value
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ThinkingChunk instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ThinkingChunk instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+
+@dataclass
+class ToolChunk(StreamChunk):
+    """A tool call chunk from the LLM response stream.
+
+    Attributes
+    ----------
+    kind : str
+        The kind identifier for tool chunks
+    tool_call : ToolCall
+        The tool call data
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="tool")
+    tool_call: ToolCall = field(default_factory=ToolCall)
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ToolChunk":
+        """Load a ToolChunk instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ToolChunk: The loaded ToolChunk instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ToolChunk: {data}")
+
+        # create new instance
+        instance = ToolChunk()
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if data is not None and "toolCall" in data:
+            instance.tool_call = ToolCall.load(data["toolCall"], context)
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ToolChunk instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        # Start with parent class properties
+        result = super().save(context)
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+        if obj.tool_call is not None:
+            result["toolCall"] = obj.tool_call.save(context)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ToolChunk instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ToolChunk instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+
+@dataclass
+class ErrorChunk(StreamChunk):
+    """An error chunk from the LLM response stream.
+
+    Attributes
+    ----------
+    kind : str
+        The kind identifier for error chunks
+    message : str
+        The error message
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    kind: str = field(default="error")
+    message: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ErrorChunk":
+        """Load a ErrorChunk instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ErrorChunk: The loaded ErrorChunk instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ErrorChunk: {data}")
+
+        # create new instance
+        instance = ErrorChunk()
+
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if data is not None and "message" in data:
+            instance.message = data["message"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ErrorChunk instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        # Start with parent class properties
+        result = super().save(context)
+
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+        if obj.message is not None:
+            result["message"] = obj.message
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ErrorChunk instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ErrorChunk instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_ThinkingEventPayload.py b/runtime/python/prompty/prompty/model/_ThinkingEventPayload.py
new file mode 100644
index 00000000..75717173
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ThinkingEventPayload.py
@@ -0,0 +1,97 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class ThinkingEventPayload:
+    """Payload for "thinking" events — reasoning/chain-of-thought tokens.
+
+    Attributes
+    ----------
+    token : str
+        The thinking/reasoning token text
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    token: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ThinkingEventPayload":
+        """Load a ThinkingEventPayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ThinkingEventPayload: The loaded ThinkingEventPayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ThinkingEventPayload: {data}")
+
+        # create new instance
+        instance = ThinkingEventPayload()
+
+        if data is not None and "token" in data:
+            instance.token = data["token"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ThinkingEventPayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.token is not None:
+            result["token"] = obj.token
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ThinkingEventPayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ThinkingEventPayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_ThreadMarker.py b/runtime/python/prompty/prompty/model/_ThreadMarker.py
new file mode 100644
index 00000000..e348a499
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ThreadMarker.py
@@ -0,0 +1,108 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class ThreadMarker:
+    """Positional marker for conversation history insertion during template rendering.
+
+    During `prepare()`, nonce strings in rendered text are replaced with
+    ThreadMarker objects. The pipeline then replaces them with actual
+    conversation messages from the inputs.
+
+    Attributes
+    ----------
+    name : str
+        The input property name (e.g. 'conversation')
+    kind : str
+        The rich kind ('thread', 'image', 'file', 'audio')
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    name: str = field(default="thread")
+    kind: str = field(default="thread")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ThreadMarker":
+        """Load a ThreadMarker instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ThreadMarker: The loaded ThreadMarker instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ThreadMarker: {data}")
+
+        # create new instance
+        instance = ThreadMarker()
+
+        if data is not None and "name" in data:
+            instance.name = data["name"]
+        if data is not None and "kind" in data:
+            instance.kind = data["kind"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ThreadMarker instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.name is not None:
+            result["name"] = obj.name
+        if obj.kind is not None:
+            result["kind"] = obj.kind
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ThreadMarker instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ThreadMarker instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_TokenEventPayload.py b/runtime/python/prompty/prompty/model/_TokenEventPayload.py
new file mode 100644
index 00000000..c0bd5efe
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_TokenEventPayload.py
@@ -0,0 +1,97 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class TokenEventPayload:
+    """Payload for "token" events — a single text token streamed from the LLM.
+
+    Attributes
+    ----------
+    token : str
+        The streamed token text
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    token: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "TokenEventPayload":
+        """Load a TokenEventPayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            TokenEventPayload: The loaded TokenEventPayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for TokenEventPayload: {data}")
+
+        # create new instance
+        instance = TokenEventPayload()
+
+        if data is not None and "token" in data:
+            instance.token = data["token"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the TokenEventPayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.token is not None:
+            result["token"] = obj.token
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the TokenEventPayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the TokenEventPayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_TokenUsage.py b/runtime/python/prompty/prompty/model/_TokenUsage.py
new file mode 100644
index 00000000..f1fb2393
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_TokenUsage.py
@@ -0,0 +1,134 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class TokenUsage:
+    """Tracks token consumption for a single LLM call. Provider-specific field
+    names (e.g., OpenAI's `prompt_tokens` vs Anthropic's `input_tokens`)
+    are mapped via `knownAs` augments in the wire directory.
+
+    Attributes
+    ----------
+    prompt_tokens : Optional[int]
+        Number of tokens in the prompt/input sent to the model
+    completion_tokens : Optional[int]
+        Number of tokens generated in the model's completion/output
+    total_tokens : Optional[int]
+        Total tokens consumed (prompt + completion). May be provided by the API or computed.
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    prompt_tokens: int | None = None
+    completion_tokens: int | None = None
+    total_tokens: int | None = None
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "TokenUsage":
+        """Load a TokenUsage instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            TokenUsage: The loaded TokenUsage instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for TokenUsage: {data}")
+
+        # create new instance
+        instance = TokenUsage()
+
+        if data is not None and "promptTokens" in data:
+            instance.prompt_tokens = data["promptTokens"]
+        if data is not None and "completionTokens" in data:
+            instance.completion_tokens = data["completionTokens"]
+        if data is not None and "totalTokens" in data:
+            instance.total_tokens = data["totalTokens"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the TokenUsage instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.prompt_tokens is not None:
+            result["promptTokens"] = obj.prompt_tokens
+        if obj.completion_tokens is not None:
+            result["completionTokens"] = obj.completion_tokens
+        if obj.total_tokens is not None:
+            result["totalTokens"] = obj.total_tokens
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_wire(self, provider: str) -> dict[str, Any]:
+        """Convert to provider-specific wire format.
+        Args:
+            provider (str): The provider to convert to (e.g., "openai", "anthropic").
+        Returns:
+            dict[str, Any]: The wire-format dictionary with provider-specific field names.
+
+        """
+        data = self.save()
+        result: dict[str, Any] = {}
+        wire_map: dict[str, dict[str, str]] = {
+            "promptTokens": {"openai": "prompt_tokens", "anthropic": "input_tokens"},
+            "completionTokens": {"openai": "completion_tokens", "anthropic": "output_tokens"},
+            "totalTokens": {"openai": "total_tokens"},
+        }
+        for key, value in data.items():
+            mapping = wire_map.get(key)
+            if mapping is not None and provider in mapping:
+                result[mapping[provider]] = value
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the TokenUsage instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the TokenUsage instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_Tool.py b/runtime/python/prompty/prompty/model/_Tool.py
index 4dca47db..76d91071 100644
--- a/runtime/python/prompty/prompty/model/_Tool.py
+++ b/runtime/python/prompty/prompty/model/_Tool.py
@@ -27,7 +27,7 @@ class Tool(ABC):
         The kind identifier for the tool
     description : Optional[str]
         A short description of the tool for metadata purposes
-    bindings : list[Binding]
+    bindings : Optional[list[Binding]]
         Tool argument bindings to input properties
     """
 
@@ -130,7 +130,6 @@ def load_kind(data: dict, context: LoadContext | None) -> "Tool":
             else:
                 # load default instance
                 return CustomTool.load(data, context)
-
         else:
             raise ValueError("Missing Tool discriminator property: 'kind'")
 
@@ -248,7 +247,7 @@ def load_parameters(data: dict | list, context: LoadContext | None) -> list[Prop
                     result.append({"name": k, **v})
                 else:
                     # value is a scalar, use it as the primary property
-                    result.append({"name": k, "": v})
+                    result.append({"name": k, "kind": v})
             data = result
         return [Property.load(item, context) for item in data]
 
@@ -257,28 +256,8 @@ def save_parameters(items: list[Property], context: SaveContext | None) -> dict[
         if context is None:
             context = SaveContext()
 
-        if context.collection_format == "array":
-            return [item.save(context) for item in items]
-
-        # Object format: use name as key
-        result: dict[str, Any] = {}
-        for item in items:
-            item_data = item.save(context)
-            name = item_data.pop("name", None)
-            if name:
-                # Check if we can use shorthand (only primary property set)
-                if context.use_shorthand and hasattr(item, "_shorthand_property"):
-                    shorthand_prop = item._shorthand_property
-                    if shorthand_prop and len(item_data) == 1 and shorthand_prop in item_data:
-                        result[name] = item_data[shorthand_prop]
-                        continue
-                result[name] = item_data
-            else:
-                # No name, fall back to array format for this item
-                if "_unnamed" not in result:
-                    result["_unnamed"] = []
-                result["_unnamed"].append(item_data)
-        return result
+        # This type doesn't have a 'name' property, so always use array format
+        return [item.save(context) for item in items]
 
     def save(self, context: SaveContext | None = None) -> dict[str, Any]:
         """Save the FunctionTool instance to a dictionary.
@@ -301,7 +280,6 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["parameters"] = FunctionTool.save_parameters(obj.parameters, context)
         if obj.strict is not None:
             result["strict"] = obj.strict
-
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
@@ -405,7 +383,6 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["connection"] = obj.connection.save(context)
         if obj.options is not None:
             result["options"] = obj.options
-
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
@@ -444,13 +421,13 @@ class McpTool(Tool):
         The kind identifier for MCP tools
     connection : Connection
         The connection configuration for the MCP tool
-    serverName : str
+    server_name : str
         The server name of the MCP tool
-    serverDescription : Optional[str]
+    server_description : Optional[str]
         The description of the MCP tool
-    approvalMode : McpApprovalMode
+    approval_mode : McpApprovalMode
         The approval mode for the MCP tool
-    allowedTools : list[str]
+    allowed_tools : Optional[list[str]]
         List of allowed operations or resources for the MCP tool
     """
 
@@ -458,10 +435,10 @@ class McpTool(Tool):
 
     kind: str = field(default="mcp")
     connection: Connection = field(default_factory=Connection)
-    serverName: str = field(default="")
-    serverDescription: str | None = None
-    approvalMode: McpApprovalMode = field(default_factory=McpApprovalMode)
-    allowedTools: list[str] = field(default_factory=list)
+    server_name: str = field(default="")
+    server_description: str | None = None
+    approval_mode: McpApprovalMode = field(default_factory=McpApprovalMode)
+    allowed_tools: list[str] = field(default_factory=list)
 
     @staticmethod
     def load(data: Any, context: LoadContext | None = None) -> "McpTool":
@@ -488,13 +465,13 @@ def load(data: Any, context: LoadContext | None = None) -> "McpTool":
         if data is not None and "connection" in data:
             instance.connection = Connection.load(data["connection"], context)
         if data is not None and "serverName" in data:
-            instance.serverName = data["serverName"]
+            instance.server_name = data["serverName"]
         if data is not None and "serverDescription" in data:
-            instance.serverDescription = data["serverDescription"]
+            instance.server_description = data["serverDescription"]
         if data is not None and "approvalMode" in data:
-            instance.approvalMode = McpApprovalMode.load(data["approvalMode"], context)
+            instance.approval_mode = McpApprovalMode.load(data["approvalMode"], context)
         if data is not None and "allowedTools" in data:
-            instance.allowedTools = data["allowedTools"]
+            instance.allowed_tools = data["allowedTools"]
         if context is not None:
             instance = context.process_output(instance)
         return instance
@@ -518,15 +495,14 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["kind"] = obj.kind
         if obj.connection is not None:
             result["connection"] = obj.connection.save(context)
-        if obj.serverName is not None:
-            result["serverName"] = obj.serverName
-        if obj.serverDescription is not None:
-            result["serverDescription"] = obj.serverDescription
-        if obj.approvalMode is not None:
-            result["approvalMode"] = obj.approvalMode.save(context)
-        if obj.allowedTools is not None:
-            result["allowedTools"] = obj.allowedTools
-
+        if obj.server_name is not None:
+            result["serverName"] = obj.server_name
+        if obj.server_description is not None:
+            result["serverDescription"] = obj.server_description
+        if obj.approval_mode is not None:
+            result["approvalMode"] = obj.approval_mode.save(context)
+        if obj.allowed_tools is not None:
+            result["allowedTools"] = obj.allowed_tools
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
@@ -626,7 +602,6 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["connection"] = obj.connection.save(context)
         if obj.specification is not None:
             result["specification"] = obj.specification
-
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
@@ -729,7 +704,6 @@ def save(self, context: SaveContext | None = None) -> dict[str, Any]:
             result["path"] = obj.path
         if obj.mode is not None:
             result["mode"] = obj.mode
-
         return result
 
     def to_yaml(self, context: SaveContext | None = None) -> str:
diff --git a/runtime/python/prompty/prompty/model/_ToolCall.py b/runtime/python/prompty/prompty/model/_ToolCall.py
new file mode 100644
index 00000000..336d2802
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ToolCall.py
@@ -0,0 +1,112 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class ToolCall:
+    """A tool call requested by the LLM. Contains the function name and serialized
+    arguments that should be dispatched to the appropriate tool handler.
+
+    Attributes
+    ----------
+    id : str
+        The unique identifier of the tool call
+    name : str
+        The name of the tool to call
+    arguments : str
+        The serialized JSON arguments for the tool call
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    id: str = field(default="")
+    name: str = field(default="")
+    arguments: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ToolCall":
+        """Load a ToolCall instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ToolCall: The loaded ToolCall instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ToolCall: {data}")
+
+        # create new instance
+        instance = ToolCall()
+
+        if data is not None and "id" in data:
+            instance.id = data["id"]
+        if data is not None and "name" in data:
+            instance.name = data["name"]
+        if data is not None and "arguments" in data:
+            instance.arguments = data["arguments"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ToolCall instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.id is not None:
+            result["id"] = obj.id
+        if obj.name is not None:
+            result["name"] = obj.name
+        if obj.arguments is not None:
+            result["arguments"] = obj.arguments
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ToolCall instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ToolCall instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_ToolCallStartPayload.py b/runtime/python/prompty/prompty/model/_ToolCallStartPayload.py
new file mode 100644
index 00000000..a111c73d
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ToolCallStartPayload.py
@@ -0,0 +1,104 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class ToolCallStartPayload:
+    """Payload for "tool_call_start" events — the LLM has requested a tool call.
+
+    Attributes
+    ----------
+    name : str
+        The name of the tool being called
+    arguments : str
+        The serialized JSON arguments for the tool call
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    name: str = field(default="")
+    arguments: str = field(default="")
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ToolCallStartPayload":
+        """Load a ToolCallStartPayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ToolCallStartPayload: The loaded ToolCallStartPayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ToolCallStartPayload: {data}")
+
+        # create new instance
+        instance = ToolCallStartPayload()
+
+        if data is not None and "name" in data:
+            instance.name = data["name"]
+        if data is not None and "arguments" in data:
+            instance.arguments = data["arguments"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ToolCallStartPayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.name is not None:
+            result["name"] = obj.name
+        if obj.arguments is not None:
+            result["arguments"] = obj.arguments
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ToolCallStartPayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ToolCallStartPayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_ToolContext.py b/runtime/python/prompty/prompty/model/_ToolContext.py
new file mode 100644
index 00000000..38c39187
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ToolContext.py
@@ -0,0 +1,130 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+from ._Message import Message
+
+
+@dataclass
+class ToolContext:
+    """Context passed to tool handlers during agent loop execution. Provides
+    access to the agent configuration, current conversation state, and
+    arbitrary metadata for tool implementations that need broader context.
+
+    Attributes
+    ----------
+    messages : list[Message]
+        The current conversation messages at the point of tool invocation
+    metadata : Optional[dict[str, Any]]
+        Optional metadata for tool-specific context (e.g., user session info)
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    messages: list[Message] = field(default_factory=list)
+    metadata: dict[str, Any] | None = None
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ToolContext":
+        """Load a ToolContext instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ToolContext: The loaded ToolContext instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ToolContext: {data}")
+
+        # create new instance
+        instance = ToolContext()
+
+        if data is not None and "messages" in data:
+            instance.messages = ToolContext.load_messages(data["messages"], context)
+        if data is not None and "metadata" in data:
+            instance.metadata = data["metadata"]
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    @staticmethod
+    def load_messages(data: dict | list, context: LoadContext | None) -> list[Message]:
+        if isinstance(data, dict):
+            # convert simple named messages to list of Message
+            result = []
+            for k, v in data.items():
+                if isinstance(v, dict):
+                    # value is an object, spread its properties
+                    result.append({"name": k, **v})
+                else:
+                    # value is a scalar, use it as the primary property
+                    result.append({"name": k, "role": v})
+            data = result
+        return [Message.load(item, context) for item in data]
+
+    @staticmethod
+    def save_messages(items: list[Message], context: SaveContext | None) -> dict[str, Any] | list[dict[str, Any]]:
+        if context is None:
+            context = SaveContext()
+
+        # This type doesn't have a 'name' property, so always use array format
+        return [item.save(context) for item in items]
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ToolContext instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.messages is not None:
+            result["messages"] = ToolContext.save_messages(obj.messages, context)
+        if obj.metadata is not None:
+            result["metadata"] = obj.metadata
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ToolContext instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ToolContext instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_ToolDispatchResult.py b/runtime/python/prompty/prompty/model/_ToolDispatchResult.py
new file mode 100644
index 00000000..8088d660
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ToolDispatchResult.py
@@ -0,0 +1,114 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+from ._ToolResult import ToolResult
+
+
+@dataclass
+class ToolDispatchResult:
+    """The result of dispatching a single tool call. Pairs the tool call
+    identifier with the tool's name and result for correlation in the
+    agent loop's message assembly.
+
+    Attributes
+    ----------
+    tool_call_id : str
+        The tool call ID from the LLM response, used to correlate results
+    name : str
+        The name of the tool that was called
+    result : ToolResult
+        The result produced by the tool handler
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    tool_call_id: str = field(default="")
+    name: str = field(default="")
+    result: ToolResult = field(default_factory=ToolResult)
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ToolDispatchResult":
+        """Load a ToolDispatchResult instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ToolDispatchResult: The loaded ToolDispatchResult instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ToolDispatchResult: {data}")
+
+        # create new instance
+        instance = ToolDispatchResult()
+
+        if data is not None and "toolCallId" in data:
+            instance.tool_call_id = data["toolCallId"]
+        if data is not None and "name" in data:
+            instance.name = data["name"]
+        if data is not None and "result" in data:
+            instance.result = ToolResult.load(data["result"], context)
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ToolDispatchResult instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.tool_call_id is not None:
+            result["toolCallId"] = obj.tool_call_id
+        if obj.name is not None:
+            result["name"] = obj.name
+        if obj.result is not None:
+            result["result"] = obj.result.save(context)
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ToolDispatchResult instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ToolDispatchResult instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_ToolResult.py b/runtime/python/prompty/prompty/model/_ToolResult.py
new file mode 100644
index 00000000..730786f9
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ToolResult.py
@@ -0,0 +1,146 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar, Protocol, runtime_checkable
+
+from ._ContentPart import ContentPart, TextPart
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class ToolResult:
+    """The result of a tool execution. Contains a list of content parts, enabling
+    rich tool results (text, images, files, audio) rather than just strings.
+
+    Implementations MUST support conversion from a plain string to a ToolResult
+    containing a single TextPart for backward compatibility.
+
+    Attributes
+    ----------
+    parts : list[ContentPart]
+        The content parts of the tool result
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    parts: list[ContentPart] = field(default_factory=list)
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ToolResult":
+        """Load a ToolResult instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ToolResult: The loaded ToolResult instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ToolResult: {data}")
+
+        # create new instance
+        instance = ToolResult()
+
+        if data is not None and "parts" in data:
+            instance.parts = ToolResult.load_parts(data["parts"], context)
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    @staticmethod
+    def load_parts(data: dict | list, context: LoadContext | None) -> list[ContentPart]:
+        if isinstance(data, dict):
+            # convert simple named parts to list of ContentPart
+            result = []
+            for k, v in data.items():
+                if isinstance(v, dict):
+                    # value is an object, spread its properties
+                    result.append({"name": k, **v})
+                else:
+                    # value is a scalar, use it as the primary property
+                    result.append({"name": k, "kind": v})
+            data = result
+        return [ContentPart.load(item, context) for item in data]
+
+    @staticmethod
+    def save_parts(items: list[ContentPart], context: SaveContext | None) -> dict[str, Any] | list[dict[str, Any]]:
+        if context is None:
+            context = SaveContext()
+
+        # This type doesn't have a 'name' property, so always use array format
+        return [item.save(context) for item in items]
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ToolResult instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.parts is not None:
+            result["parts"] = ToolResult.save_parts(obj.parts, context)
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ToolResult instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ToolResult instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
+
+    @classmethod
+    def text(cls, value: str) -> "ToolResult":
+        """Create a ToolResult with preset field values."""
+        return ToolResult(parts=[TextPart(value=value)])
+
+
+@runtime_checkable
+class ToolResultHelpers(Protocol):
+    """Helper contract for ToolResult.
+
+    Runtime implementations must provide these methods on every ToolResult
+    instance (either by attaching them to the generated class or by wrapping it).
+    The type checker can verify conformance by annotating against this Protocol
+    or by calling isinstance(instance, ToolResultHelpers) at runtime.
+    """
+
+    @property
+    def text(self) -> str:
+        """Concatenate all TextPart values joined by newline"""
+        ...
diff --git a/runtime/python/prompty/prompty/model/_ToolResultPayload.py b/runtime/python/prompty/prompty/model/_ToolResultPayload.py
new file mode 100644
index 00000000..28559e85
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_ToolResultPayload.py
@@ -0,0 +1,105 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from ._context import LoadContext, SaveContext
+from ._ToolResult import ToolResult
+
+
+@dataclass
+class ToolResultPayload:
+    """Payload for "tool_result" events — a tool has returned its result.
+
+    Attributes
+    ----------
+    name : str
+        The name of the tool that produced the result
+    result : ToolResult
+        The tool's result
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    name: str = field(default="")
+    result: ToolResult = field(default_factory=ToolResult)
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "ToolResultPayload":
+        """Load a ToolResultPayload instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            ToolResultPayload: The loaded ToolResultPayload instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for ToolResultPayload: {data}")
+
+        # create new instance
+        instance = ToolResultPayload()
+
+        if data is not None and "name" in data:
+            instance.name = data["name"]
+        if data is not None and "result" in data:
+            instance.result = ToolResult.load(data["result"], context)
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the ToolResultPayload instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.name is not None:
+            result["name"] = obj.name
+        if obj.result is not None:
+            result["result"] = obj.result.save(context)
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the ToolResultPayload instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the ToolResultPayload instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/_TurnOptions.py b/runtime/python/prompty/prompty/model/_TurnOptions.py
new file mode 100644
index 00000000..b6aca6f1
--- /dev/null
+++ b/runtime/python/prompty/prompty/model/_TurnOptions.py
@@ -0,0 +1,145 @@
+##########################################
+# WARNING: This is an auto-generated file.
+# DO NOT EDIT THIS FILE DIRECTLY
+# ANY EDITS WILL BE LOST
+##########################################
+
+from dataclasses import dataclass
+from typing import Any, ClassVar
+
+from ._CompactionConfig import CompactionConfig
+from ._context import LoadContext, SaveContext
+
+
+@dataclass
+class TurnOptions:
+    """Configuration for the agent loop's turn() function. Controls iteration
+    limits, retry policy, context management, and execution behavior.
+
+    Runtimes accept these as either a TurnOptions object or individual
+    keyword/named parameters — the TypeSpec model defines the canonical
+    field set.
+
+    Attributes
+    ----------
+    max_iterations : Optional[int]
+        Maximum number of tool-call iterations before the loop terminates
+    max_llm_retries : Optional[int]
+        Maximum number of LLM call retries on transient failure within a single iteration
+    context_budget : Optional[int]
+        Character budget for the context window. When set, the loop trims older messages to stay within budget before each LLM call. System messages are never dropped.
+    parallel_tool_calls : Optional[bool]
+        Whether to execute multiple tool calls concurrently when the LLM returns several in one response
+    raw : Optional[bool]
+        When true, return the raw LLM response without processor post-processing
+    turn : Optional[int]
+        Turn number for trace labeling. Useful when the caller maintains an outer conversation loop.
+    compaction : Optional[CompactionConfig]
+        Context compaction configuration. Controls how messages are summarized when the context window exceeds the budget.
+    """
+
+    _shorthand_property: ClassVar[str | None] = None
+
+    max_iterations: int | None = None
+    max_llm_retries: int | None = None
+    context_budget: int | None = None
+    parallel_tool_calls: bool | None = None
+    raw: bool | None = None
+    turn: int | None = None
+    compaction: CompactionConfig | None = None
+
+    @staticmethod
+    def load(data: Any, context: LoadContext | None = None) -> "TurnOptions":
+        """Load a TurnOptions instance.
+        Args:
+            data (Any): The data to load the instance from.
+            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            TurnOptions: The loaded TurnOptions instance.
+
+        """
+
+        if context is not None:
+            data = context.process_input(data)
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid data for TurnOptions: {data}")
+
+        # create new instance
+        instance = TurnOptions()
+
+        if data is not None and "maxIterations" in data:
+            instance.max_iterations = data["maxIterations"]
+        if data is not None and "maxLlmRetries" in data:
+            instance.max_llm_retries = data["maxLlmRetries"]
+        if data is not None and "contextBudget" in data:
+            instance.context_budget = data["contextBudget"]
+        if data is not None and "parallelToolCalls" in data:
+            instance.parallel_tool_calls = data["parallelToolCalls"]
+        if data is not None and "raw" in data:
+            instance.raw = data["raw"]
+        if data is not None and "turn" in data:
+            instance.turn = data["turn"]
+        if data is not None and "compaction" in data:
+            instance.compaction = CompactionConfig.load(data["compaction"], context)
+        if context is not None:
+            instance = context.process_output(instance)
+        return instance
+
+    def save(self, context: SaveContext | None = None) -> dict[str, Any]:
+        """Save the TurnOptions instance to a dictionary.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            dict[str, Any]: The dictionary representation of this instance.
+
+        """
+        obj = self
+        if context is not None:
+            obj = context.process_object(obj)
+
+        result: dict[str, Any] = {}
+
+        if obj.max_iterations is not None:
+            result["maxIterations"] = obj.max_iterations
+        if obj.max_llm_retries is not None:
+            result["maxLlmRetries"] = obj.max_llm_retries
+        if obj.context_budget is not None:
+            result["contextBudget"] = obj.context_budget
+        if obj.parallel_tool_calls is not None:
+            result["parallelToolCalls"] = obj.parallel_tool_calls
+        if obj.raw is not None:
+            result["raw"] = obj.raw
+        if obj.turn is not None:
+            result["turn"] = obj.turn
+        if obj.compaction is not None:
+            result["compaction"] = obj.compaction.save(context)
+
+        if context is not None:
+            result = context.process_dict(result)
+        return result
+
+    def to_yaml(self, context: SaveContext | None = None) -> str:
+        """Convert the TurnOptions instance to a YAML string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+        Returns:
+            str: The YAML string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_yaml(self.save(context))
+
+    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:
+        """Convert the TurnOptions instance to a JSON string.
+        Args:
+            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
+            indent (int): Number of spaces for indentation. Defaults to 2.
+        Returns:
+            str: The JSON string representation of this instance.
+
+        """
+        if context is None:
+            context = SaveContext()
+        return context.to_json(self.save(context), indent)
diff --git a/runtime/python/prompty/prompty/model/__init__.py b/runtime/python/prompty/prompty/model/__init__.py
index f06bd034..a3c6c011 100644
--- a/runtime/python/prompty/prompty/model/__init__.py
+++ b/runtime/python/prompty/prompty/model/__init__.py
@@ -4,6 +4,9 @@
 # ANY EDITS WILL BE LOST
 ##########################################
 from ._Binding import Binding
+from ._CompactionCompletePayload import CompactionCompletePayload
+from ._CompactionConfig import CompactionConfig
+from ._CompactionFailedPayload import CompactionFailedPayload
 from ._Connection import (
     AnonymousConnection,
     ApiKeyConnection,
@@ -13,16 +16,69 @@
     ReferenceConnection,
     RemoteConnection,
 )
+from ._ContentPart import (
+    AudioPart,
+    ContentPart,
+    FilePart,
+    ImagePart,
+    TextPart,
+)
 from ._context import LoadContext, SaveContext
+from ._DoneEventPayload import DoneEventPayload
+from ._ErrorEventPayload import ErrorEventPayload
+from ._Executor import Executor
 from ._FormatConfig import FormatConfig
+from ._GuardrailResult import GuardrailResult
 from ._McpApprovalMode import McpApprovalMode
+from ._Message import (
+    Message,
+    MessageHelpers,
+)
+from ._MessagesUpdatedPayload import MessagesUpdatedPayload
 from ._Model import Model
+from ._ModelInfo import ModelInfo
 from ._ModelOptions import ModelOptions
+from ._Parser import Parser
 from ._ParserConfig import ParserConfig
+from ._Processor import Processor
 from ._Prompty import Prompty
-from ._Property import ArrayProperty, ObjectProperty, Property
+from ._Property import (
+    ArrayProperty,
+    ObjectProperty,
+    Property,
+)
+from ._Renderer import Renderer
+from ._StatusEventPayload import StatusEventPayload
+from ._StreamChunk import (
+    ErrorChunk,
+    StreamChunk,
+    TextChunk,
+    ThinkingChunk,
+    ToolChunk,
+)
 from ._Template import Template
-from ._Tool import CustomTool, FunctionTool, McpTool, OpenApiTool, PromptyTool, Tool
+from ._ThinkingEventPayload import ThinkingEventPayload
+from ._ThreadMarker import ThreadMarker
+from ._TokenEventPayload import TokenEventPayload
+from ._TokenUsage import TokenUsage
+from ._Tool import (
+    CustomTool,
+    FunctionTool,
+    McpTool,
+    OpenApiTool,
+    PromptyTool,
+    Tool,
+)
+from ._ToolCall import ToolCall
+from ._ToolCallStartPayload import ToolCallStartPayload
+from ._ToolContext import ToolContext
+from ._ToolDispatchResult import ToolDispatchResult
+from ._ToolResult import (
+    ToolResult,
+    ToolResultHelpers,
+)
+from ._ToolResultPayload import ToolResultPayload
+from ._TurnOptions import TurnOptions
 
 __all__ = [
     "LoadContext",
@@ -35,8 +91,8 @@
     "RemoteConnection",
     "ApiKeyConnection",
     "AnonymousConnection",
-    "FoundryConnection",
     "OAuthConnection",
+    "FoundryConnection",
     "ModelOptions",
     "Model",
     "Binding",
@@ -51,4 +107,41 @@
     "ParserConfig",
     "Template",
     "Prompty",
+    "ContentPart",
+    "TextPart",
+    "ImagePart",
+    "FilePart",
+    "AudioPart",
+    "Message",
+    "MessageHelpers",
+    "ToolContext",
+    "ToolResult",
+    "ToolResultHelpers",
+    "ToolDispatchResult",
+    "ToolCall",
+    "GuardrailResult",
+    "ThreadMarker",
+    "TokenUsage",
+    "ModelInfo",
+    "CompactionConfig",
+    "TurnOptions",
+    "Renderer",
+    "Parser",
+    "Executor",
+    "Processor",
+    "TokenEventPayload",
+    "ThinkingEventPayload",
+    "ToolCallStartPayload",
+    "ToolResultPayload",
+    "StatusEventPayload",
+    "MessagesUpdatedPayload",
+    "DoneEventPayload",
+    "ErrorEventPayload",
+    "CompactionCompletePayload",
+    "CompactionFailedPayload",
+    "StreamChunk",
+    "TextChunk",
+    "ThinkingChunk",
+    "ToolChunk",
+    "ErrorChunk",
 ]
diff --git a/runtime/python/prompty/prompty/providers/anthropic/executor.py b/runtime/python/prompty/prompty/providers/anthropic/executor.py
index 74c587ef..4ed3db8a 100644
--- a/runtime/python/prompty/prompty/providers/anthropic/executor.py
+++ b/runtime/python/prompty/prompty/providers/anthropic/executor.py
@@ -130,20 +130,11 @@ def _build_options(agent: Prompty) -> dict[str, Any]:
     if opts is None:
         return {}
 
-    result: dict[str, Any] = {}
-
-    if opts.temperature is not None:
-        result["temperature"] = opts.temperature
-    if opts.topP is not None:
-        result["top_p"] = opts.topP
-    if opts.topK is not None:
-        result["top_k"] = opts.topK
-    if opts.stopSequences:
-        result["stop_sequences"] = opts.stopSequences
+    result = opts.to_wire("anthropic")
 
     # Pass through additionalProperties
-    if opts.additionalProperties:
-        for k, v in opts.additionalProperties.items():
+    if opts.additional_properties:
+        for k, v in opts.additional_properties.items():
             if k not in result and k != "max_tokens":
                 result[k] = v
 
@@ -170,8 +161,8 @@ def _property_to_json_schema(prop: Any) -> dict[str, Any]:
 
     if hasattr(prop, "description") and prop.description:
         schema["description"] = prop.description
-    if hasattr(prop, "enumValues") and prop.enumValues:
-        schema["enum"] = prop.enumValues
+    if hasattr(prop, "enum_values") and prop.enum_values:
+        schema["enum"] = prop.enum_values
 
     if getattr(prop, "kind", None) == "array":
         items = getattr(prop, "items", None)
@@ -289,15 +280,14 @@ def _build_chat_args(agent: Prompty, messages: list[Message]) -> dict[str, Any]:
         else:
             conversation.append(_message_to_wire(msg))
 
-    max_tokens = DEFAULT_MAX_TOKENS
-    if agent.model.options and agent.model.options.maxOutputTokens is not None:
-        max_tokens = agent.model.options.maxOutputTokens
+    opts = _build_options(agent)
+    if "max_tokens" not in opts:
+        opts["max_tokens"] = DEFAULT_MAX_TOKENS
 
     args: dict[str, Any] = {
         "model": model,
         "messages": conversation,
-        "max_tokens": max_tokens,
-        **_build_options(agent),
+        **opts,
     }
 
     if system_parts:
@@ -333,7 +323,7 @@ class AnthropicExecutor:
     @trace
     def execute(self, agent: Prompty, data: Any) -> Any:
         client = self._resolve_client(agent)
-        api_type = agent.model.apiType or "chat"
+        api_type = agent.model.api_type or "chat"
 
         if api_type == "chat":
             return self._execute_chat(client, agent, data)
@@ -345,7 +335,7 @@ def execute(self, agent: Prompty, data: Any) -> Any:
     @trace
     async def execute_async(self, agent: Prompty, data: Any) -> Any:
         client = self._resolve_client_async(agent)
-        api_type = agent.model.apiType or "chat"
+        api_type = agent.model.api_type or "chat"
 
         if api_type == "chat":
             return await self._execute_chat_async(client, agent, data)
@@ -413,8 +403,8 @@ def _client_kwargs(self, agent: Prompty) -> dict[str, Any]:
         conn = agent.model.connection
 
         if isinstance(conn, ApiKeyConnection):
-            if conn.apiKey:
-                kwargs["api_key"] = conn.apiKey
+            if conn.api_key:
+                kwargs["api_key"] = conn.api_key
             if conn.endpoint:
                 kwargs["base_url"] = conn.endpoint
         elif conn:
diff --git a/runtime/python/prompty/prompty/providers/foundry/executor.py b/runtime/python/prompty/prompty/providers/foundry/executor.py
index 24886754..e0485b8e 100644
--- a/runtime/python/prompty/prompty/providers/foundry/executor.py
+++ b/runtime/python/prompty/prompty/providers/foundry/executor.py
@@ -50,7 +50,7 @@ class FoundryExecutor(_BaseExecutor):
     @trace
     def execute(self, agent: Prompty, data: Any) -> Any:
         client = self._resolve_client(agent)
-        api_type = agent.model.apiType or "chat"
+        api_type = agent.model.api_type or "chat"
 
         if api_type == "chat":
             return self._execute_chat(client, agent, data)
@@ -66,7 +66,7 @@ def execute(self, agent: Prompty, data: Any) -> Any:
     @trace
     async def execute_async(self, agent: Prompty, data: Any) -> Any:
         client = self._resolve_client_async(agent)
-        api_type = agent.model.apiType or "chat"
+        api_type = agent.model.api_type or "chat"
 
         if api_type == "chat":
             return await self._execute_chat_async(client, agent, data)
@@ -117,7 +117,7 @@ def _build_client_from_key(self, conn: ApiKeyConnection) -> Any:
         """Build a sync AzureOpenAI client from an ApiKeyConnection."""
         from openai import AzureOpenAI
 
-        if not conn.apiKey:
+        if not conn.api_key:
             raise ValueError(
                 "Foundry connection has kind 'key' but no apiKey. "
                 "Either provide an apiKey (e.g., apiKey: ${env:AZURE_OPENAI_API_KEY}), "
@@ -128,7 +128,7 @@ def _build_client_from_key(self, conn: ApiKeyConnection) -> Any:
                 "Then call: prompty.register_connection('my-foundry', client=AzureOpenAI(...))"
             )
 
-        kwargs: dict[str, Any] = {"api_key": conn.apiKey, "api_version": "2024-12-01-preview"}
+        kwargs: dict[str, Any] = {"api_key": conn.api_key, "api_version": "2024-12-01-preview"}
         if conn.endpoint:
             kwargs["azure_endpoint"] = conn.endpoint
 
@@ -148,7 +148,7 @@ def _build_async_client_from_key(self, conn: ApiKeyConnection) -> Any:
         """Build an async AsyncAzureOpenAI client from an ApiKeyConnection."""
         from openai import AsyncAzureOpenAI
 
-        if not conn.apiKey:
+        if not conn.api_key:
             raise ValueError(
                 "Foundry connection has kind 'key' but no apiKey. "
                 "Either provide an apiKey (e.g., apiKey: ${env:AZURE_OPENAI_API_KEY}), "
@@ -159,7 +159,7 @@ def _build_async_client_from_key(self, conn: ApiKeyConnection) -> Any:
                 "Then call: prompty.register_connection('my-foundry', client=AsyncAzureOpenAI(...))"
             )
 
-        kwargs: dict[str, Any] = {"api_key": conn.apiKey, "api_version": "2024-12-01-preview"}
+        kwargs: dict[str, Any] = {"api_key": conn.api_key, "api_version": "2024-12-01-preview"}
         if conn.endpoint:
             kwargs["azure_endpoint"] = conn.endpoint
 
diff --git a/runtime/python/prompty/prompty/providers/openai/executor.py b/runtime/python/prompty/prompty/providers/openai/executor.py
index bff668c7..ded8fe09 100644
--- a/runtime/python/prompty/prompty/providers/openai/executor.py
+++ b/runtime/python/prompty/prompty/providers/openai/executor.py
@@ -204,8 +204,8 @@ def _property_to_json_schema(prop) -> dict[str, Any]:
 
     if prop.description:
         schema["description"] = prop.description
-    if prop.enumValues:
-        schema["enum"] = prop.enumValues
+    if prop.enum_values:
+        schema["enum"] = prop.enum_values
 
     # Array items — default to string if unspecified
     if prop.kind == "array":
@@ -270,30 +270,15 @@ def _output_schema_to_wire(agent: Prompty) -> dict[str, Any] | None:
 
 def _build_options(agent: Prompty) -> dict[str, Any]:
     """Extract model options into kwargs for the chat completions API call."""
-    opts: dict[str, Any] = {}
     if agent.model.options is None:
-        return opts
+        return {}
 
     mo = agent.model.options
-
-    if mo.temperature is not None:
-        opts["temperature"] = mo.temperature
-    if mo.maxOutputTokens is not None:
-        opts["max_completion_tokens"] = mo.maxOutputTokens
-    if mo.topP is not None:
-        opts["top_p"] = mo.topP
-    if mo.frequencyPenalty is not None:
-        opts["frequency_penalty"] = mo.frequencyPenalty
-    if mo.presencePenalty is not None:
-        opts["presence_penalty"] = mo.presencePenalty
-    if mo.seed is not None:
-        opts["seed"] = mo.seed
-    if mo.stopSequences:
-        opts["stop"] = mo.stopSequences
+    opts = mo.to_wire("openai")
 
     # Pass through additional properties
-    if mo.additionalProperties:
-        for k, v in mo.additionalProperties.items():
+    if mo.additional_properties:
+        for k, v in mo.additional_properties.items():
             if k not in opts:
                 opts[k] = v
 
@@ -307,22 +292,15 @@ def _build_options(agent: Prompty) -> dict[str, Any]:
 
 def _build_responses_options(agent: Prompty) -> dict[str, Any]:
     """Extract model options for the Responses API (different param names)."""
-    opts: dict[str, Any] = {}
     if agent.model.options is None:
-        return opts
+        return {}
 
     mo = agent.model.options
-
-    if mo.temperature is not None:
-        opts["temperature"] = mo.temperature
-    if mo.maxOutputTokens is not None:
-        opts["max_output_tokens"] = mo.maxOutputTokens
-    if mo.topP is not None:
-        opts["top_p"] = mo.topP
+    opts = mo.to_wire("responses")
 
     # Pass through additional properties
-    if mo.additionalProperties:
-        for k, v in mo.additionalProperties.items():
+    if mo.additional_properties:
+        for k, v in mo.additional_properties.items():
             if k not in opts:
                 opts[k] = v
 
@@ -737,7 +715,7 @@ class OpenAIExecutor(_BaseExecutor):
     @trace
     def execute(self, agent: Prompty, data: Any) -> Any:
         client = self._resolve_client(agent)
-        api_type = agent.model.apiType or "chat"
+        api_type = agent.model.api_type or "chat"
 
         if api_type == "chat":
             return self._execute_chat(client, agent, data)
@@ -753,7 +731,7 @@ def execute(self, agent: Prompty, data: Any) -> Any:
     @trace
     async def execute_async(self, agent: Prompty, data: Any) -> Any:
         client = self._resolve_client_async(agent)
-        api_type = agent.model.apiType or "chat"
+        api_type = agent.model.api_type or "chat"
 
         if api_type == "chat":
             return await self._execute_chat_async(client, agent, data)
@@ -815,8 +793,8 @@ def _client_kwargs(self, agent: Prompty) -> dict[str, Any]:
         kwargs: dict[str, Any] = {}
         conn = agent.model.connection
         if conn and isinstance(conn, ApiKeyConnection):
-            if conn.apiKey:
-                kwargs["api_key"] = conn.apiKey
+            if conn.api_key:
+                kwargs["api_key"] = conn.api_key
             if conn.endpoint:
                 kwargs["base_url"] = conn.endpoint
         elif conn:
diff --git a/runtime/python/prompty/tests/model/test_api_key_connection.py b/runtime/python/prompty/tests/model/test_api_key_connection.py
index 73cf55ea..79616486 100644
--- a/runtime/python/prompty/tests/model/test_api_key_connection.py
+++ b/runtime/python/prompty/tests/model/test_api_key_connection.py
@@ -18,7 +18,7 @@ def test_load_json_apikeyconnection():
     assert instance is not None
     assert instance.kind == "key"
     assert instance.endpoint == "https://{your-custom-endpoint}.openai.azure.com/"
-    assert instance.apiKey == "your-api-key"
+    assert instance.api_key == "your-api-key"
 
 
 def test_load_yaml_apikeyconnection():
@@ -33,7 +33,7 @@ def test_load_yaml_apikeyconnection():
     assert instance is not None
     assert instance.kind == "key"
     assert instance.endpoint == "https://{your-custom-endpoint}.openai.azure.com/"
-    assert instance.apiKey == "your-api-key"
+    assert instance.api_key == "your-api-key"
 
 
 def test_roundtrip_json_apikeyconnection():
@@ -52,7 +52,7 @@ def test_roundtrip_json_apikeyconnection():
     assert reloaded is not None
     assert reloaded.kind == "key"
     assert reloaded.endpoint == "https://{your-custom-endpoint}.openai.azure.com/"
-    assert reloaded.apiKey == "your-api-key"
+    assert reloaded.api_key == "your-api-key"
 
 
 def test_to_json_apikeyconnection():
diff --git a/runtime/python/prompty/tests/model/test_audio_part.py b/runtime/python/prompty/tests/model/test_audio_part.py
new file mode 100644
index 00000000..aa6fb24a
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_audio_part.py
@@ -0,0 +1,81 @@
+import json
+
+import yaml
+
+from prompty.model import AudioPart
+
+
+def test_load_json_audiopart():
+    json_data = r"""
+    {
+      "source": "https://example.com/audio.wav",
+      "mediaType": "audio/wav"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = AudioPart.load(data)
+    assert instance is not None
+    assert instance.source == "https://example.com/audio.wav"
+    assert instance.media_type == "audio/wav"
+
+
+def test_load_yaml_audiopart():
+    yaml_data = r"""
+    source: "https://example.com/audio.wav"
+    mediaType: audio/wav
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = AudioPart.load(data)
+    assert instance is not None
+    assert instance.source == "https://example.com/audio.wav"
+    assert instance.media_type == "audio/wav"
+
+
+def test_roundtrip_json_audiopart():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "source": "https://example.com/audio.wav",
+      "mediaType": "audio/wav"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = AudioPart.load(original_data)
+    saved_data = instance.save()
+    reloaded = AudioPart.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.source == "https://example.com/audio.wav"
+    assert reloaded.media_type == "audio/wav"
+
+
+def test_to_json_audiopart():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "source": "https://example.com/audio.wav",
+      "mediaType": "audio/wav"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = AudioPart.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_audiopart():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "source": "https://example.com/audio.wav",
+      "mediaType": "audio/wav"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = AudioPart.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_compaction_complete_payload.py b/runtime/python/prompty/tests/model/test_compaction_complete_payload.py
new file mode 100644
index 00000000..e235eb85
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_compaction_complete_payload.py
@@ -0,0 +1,81 @@
+import json
+
+import yaml
+
+from prompty.model import CompactionCompletePayload
+
+
+def test_load_json_compactioncompletepayload():
+    json_data = r"""
+    {
+      "removed": 5,
+      "remaining": 3
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = CompactionCompletePayload.load(data)
+    assert instance is not None
+    assert instance.removed == 5
+    assert instance.remaining == 3
+
+
+def test_load_yaml_compactioncompletepayload():
+    yaml_data = r"""
+    removed: 5
+    remaining: 3
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = CompactionCompletePayload.load(data)
+    assert instance is not None
+    assert instance.removed == 5
+    assert instance.remaining == 3
+
+
+def test_roundtrip_json_compactioncompletepayload():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "removed": 5,
+      "remaining": 3
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = CompactionCompletePayload.load(original_data)
+    saved_data = instance.save()
+    reloaded = CompactionCompletePayload.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.removed == 5
+    assert reloaded.remaining == 3
+
+
+def test_to_json_compactioncompletepayload():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "removed": 5,
+      "remaining": 3
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = CompactionCompletePayload.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_compactioncompletepayload():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "removed": 5,
+      "remaining": 3
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = CompactionCompletePayload.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_compaction_config.py b/runtime/python/prompty/tests/model/test_compaction_config.py
new file mode 100644
index 00000000..ce637de9
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_compaction_config.py
@@ -0,0 +1,95 @@
+import json
+
+import yaml
+
+from prompty.model import CompactionConfig
+
+
+def test_load_json_compactionconfig():
+    json_data = r"""
+    {
+      "strategy": "summarize",
+      "budget": 50000,
+      "options": {
+        "preserveSystemMessages": true
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = CompactionConfig.load(data)
+    assert instance is not None
+    assert instance.strategy == "summarize"
+    assert instance.budget == 50000
+
+
+def test_load_yaml_compactionconfig():
+    yaml_data = r"""
+    strategy: summarize
+    budget: 50000
+    options:
+      preserveSystemMessages: true
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = CompactionConfig.load(data)
+    assert instance is not None
+    assert instance.strategy == "summarize"
+    assert instance.budget == 50000
+
+
+def test_roundtrip_json_compactionconfig():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "strategy": "summarize",
+      "budget": 50000,
+      "options": {
+        "preserveSystemMessages": true
+      }
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = CompactionConfig.load(original_data)
+    saved_data = instance.save()
+    reloaded = CompactionConfig.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.strategy == "summarize"
+    assert reloaded.budget == 50000
+
+
+def test_to_json_compactionconfig():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "strategy": "summarize",
+      "budget": 50000,
+      "options": {
+        "preserveSystemMessages": true
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = CompactionConfig.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_compactionconfig():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "strategy": "summarize",
+      "budget": 50000,
+      "options": {
+        "preserveSystemMessages": true
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = CompactionConfig.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_compaction_failed_payload.py b/runtime/python/prompty/tests/model/test_compaction_failed_payload.py
new file mode 100644
index 00000000..d7ef0d06
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_compaction_failed_payload.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import CompactionFailedPayload
+
+
+def test_load_json_compactionfailedpayload():
+    json_data = r"""
+    {
+      "message": "Summarization prompt exceeded context window"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = CompactionFailedPayload.load(data)
+    assert instance is not None
+    assert instance.message == "Summarization prompt exceeded context window"
+
+
+def test_load_yaml_compactionfailedpayload():
+    yaml_data = r"""
+    message: Summarization prompt exceeded context window
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = CompactionFailedPayload.load(data)
+    assert instance is not None
+    assert instance.message == "Summarization prompt exceeded context window"
+
+
+def test_roundtrip_json_compactionfailedpayload():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "message": "Summarization prompt exceeded context window"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = CompactionFailedPayload.load(original_data)
+    saved_data = instance.save()
+    reloaded = CompactionFailedPayload.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.message == "Summarization prompt exceeded context window"
+
+
+def test_to_json_compactionfailedpayload():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "message": "Summarization prompt exceeded context window"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = CompactionFailedPayload.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_compactionfailedpayload():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "message": "Summarization prompt exceeded context window"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = CompactionFailedPayload.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_connection.py b/runtime/python/prompty/tests/model/test_connection.py
index ee058346..872a0998 100644
--- a/runtime/python/prompty/tests/model/test_connection.py
+++ b/runtime/python/prompty/tests/model/test_connection.py
@@ -17,8 +17,8 @@ def test_load_json_connection():
     instance = Connection.load(data)
     assert instance is not None
     assert instance.kind == "reference"
-    assert instance.authenticationMode == "system"
-    assert instance.usageDescription == "This will allow the agent to respond to an email on your behalf"
+    assert instance.authentication_mode == "system"
+    assert instance.usage_description == "This will allow the agent to respond to an email on your behalf"
 
 
 def test_load_yaml_connection():
@@ -32,8 +32,8 @@ def test_load_yaml_connection():
     instance = Connection.load(data)
     assert instance is not None
     assert instance.kind == "reference"
-    assert instance.authenticationMode == "system"
-    assert instance.usageDescription == "This will allow the agent to respond to an email on your behalf"
+    assert instance.authentication_mode == "system"
+    assert instance.usage_description == "This will allow the agent to respond to an email on your behalf"
 
 
 def test_roundtrip_json_connection():
@@ -51,8 +51,8 @@ def test_roundtrip_json_connection():
     reloaded = Connection.load(saved_data)
     assert reloaded is not None
     assert reloaded.kind == "reference"
-    assert reloaded.authenticationMode == "system"
-    assert reloaded.usageDescription == "This will allow the agent to respond to an email on your behalf"
+    assert reloaded.authentication_mode == "system"
+    assert reloaded.usage_description == "This will allow the agent to respond to an email on your behalf"
 
 
 def test_to_json_connection():
diff --git a/runtime/python/prompty/tests/model/test_content_part.py b/runtime/python/prompty/tests/model/test_content_part.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_content_part.py
@@ -0,0 +1 @@
+
diff --git a/runtime/python/prompty/tests/model/test_done_event_payload.py b/runtime/python/prompty/tests/model/test_done_event_payload.py
new file mode 100644
index 00000000..fbc99566
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_done_event_payload.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import DoneEventPayload
+
+
+def test_load_json_doneeventpayload():
+    json_data = r"""
+    {
+      "response": "The weather in Paris is 72°F and sunny."
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = DoneEventPayload.load(data)
+    assert instance is not None
+    assert instance.response == "The weather in Paris is 72°F and sunny."
+
+
+def test_load_yaml_doneeventpayload():
+    yaml_data = r"""
+    response: The weather in Paris is 72°F and sunny.
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = DoneEventPayload.load(data)
+    assert instance is not None
+    assert instance.response == "The weather in Paris is 72°F and sunny."
+
+
+def test_roundtrip_json_doneeventpayload():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "response": "The weather in Paris is 72°F and sunny."
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = DoneEventPayload.load(original_data)
+    saved_data = instance.save()
+    reloaded = DoneEventPayload.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.response == "The weather in Paris is 72°F and sunny."
+
+
+def test_to_json_doneeventpayload():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "response": "The weather in Paris is 72°F and sunny."
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = DoneEventPayload.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_doneeventpayload():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "response": "The weather in Paris is 72°F and sunny."
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = DoneEventPayload.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_error_chunk.py b/runtime/python/prompty/tests/model/test_error_chunk.py
new file mode 100644
index 00000000..2116a0b5
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_error_chunk.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import ErrorChunk
+
+
+def test_load_json_errorchunk():
+    json_data = r"""
+    {
+      "message": "Rate limit exceeded"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ErrorChunk.load(data)
+    assert instance is not None
+    assert instance.message == "Rate limit exceeded"
+
+
+def test_load_yaml_errorchunk():
+    yaml_data = r"""
+    message: Rate limit exceeded
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ErrorChunk.load(data)
+    assert instance is not None
+    assert instance.message == "Rate limit exceeded"
+
+
+def test_roundtrip_json_errorchunk():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "message": "Rate limit exceeded"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ErrorChunk.load(original_data)
+    saved_data = instance.save()
+    reloaded = ErrorChunk.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.message == "Rate limit exceeded"
+
+
+def test_to_json_errorchunk():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "message": "Rate limit exceeded"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ErrorChunk.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_errorchunk():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "message": "Rate limit exceeded"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ErrorChunk.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_error_event_payload.py b/runtime/python/prompty/tests/model/test_error_event_payload.py
new file mode 100644
index 00000000..a68637b2
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_error_event_payload.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import ErrorEventPayload
+
+
+def test_load_json_erroreventpayload():
+    json_data = r"""
+    {
+      "message": "Rate limit exceeded"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ErrorEventPayload.load(data)
+    assert instance is not None
+    assert instance.message == "Rate limit exceeded"
+
+
+def test_load_yaml_erroreventpayload():
+    yaml_data = r"""
+    message: Rate limit exceeded
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ErrorEventPayload.load(data)
+    assert instance is not None
+    assert instance.message == "Rate limit exceeded"
+
+
+def test_roundtrip_json_erroreventpayload():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "message": "Rate limit exceeded"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ErrorEventPayload.load(original_data)
+    saved_data = instance.save()
+    reloaded = ErrorEventPayload.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.message == "Rate limit exceeded"
+
+
+def test_to_json_erroreventpayload():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "message": "Rate limit exceeded"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ErrorEventPayload.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_erroreventpayload():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "message": "Rate limit exceeded"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ErrorEventPayload.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_file_part.py b/runtime/python/prompty/tests/model/test_file_part.py
new file mode 100644
index 00000000..f47505b4
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_file_part.py
@@ -0,0 +1,81 @@
+import json
+
+import yaml
+
+from prompty.model import FilePart
+
+
+def test_load_json_filepart():
+    json_data = r"""
+    {
+      "source": "https://example.com/document.pdf",
+      "mediaType": "application/pdf"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = FilePart.load(data)
+    assert instance is not None
+    assert instance.source == "https://example.com/document.pdf"
+    assert instance.media_type == "application/pdf"
+
+
+def test_load_yaml_filepart():
+    yaml_data = r"""
+    source: "https://example.com/document.pdf"
+    mediaType: application/pdf
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = FilePart.load(data)
+    assert instance is not None
+    assert instance.source == "https://example.com/document.pdf"
+    assert instance.media_type == "application/pdf"
+
+
+def test_roundtrip_json_filepart():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "source": "https://example.com/document.pdf",
+      "mediaType": "application/pdf"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = FilePart.load(original_data)
+    saved_data = instance.save()
+    reloaded = FilePart.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.source == "https://example.com/document.pdf"
+    assert reloaded.media_type == "application/pdf"
+
+
+def test_to_json_filepart():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "source": "https://example.com/document.pdf",
+      "mediaType": "application/pdf"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = FilePart.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_filepart():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "source": "https://example.com/document.pdf",
+      "mediaType": "application/pdf"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = FilePart.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_format_config.py b/runtime/python/prompty/tests/model/test_format_config.py
index 436f17db..f02d7108 100644
--- a/runtime/python/prompty/tests/model/test_format_config.py
+++ b/runtime/python/prompty/tests/model/test_format_config.py
@@ -19,7 +19,6 @@ def test_load_json_formatconfig():
     instance = FormatConfig.load(data)
     assert instance is not None
     assert instance.kind == "mustache"
-
     assert instance.strict
 
 
diff --git a/runtime/python/prompty/tests/model/test_foundry_connection.py b/runtime/python/prompty/tests/model/test_foundry_connection.py
index d473bdca..8cb16477 100644
--- a/runtime/python/prompty/tests/model/test_foundry_connection.py
+++ b/runtime/python/prompty/tests/model/test_foundry_connection.py
@@ -1,97 +1,97 @@
-import json
-
-import yaml
-
-from prompty.model import FoundryConnection
-
-
-def test_load_json_foundryconnection():
-    json_data = r"""
-    {
-      "kind": "foundry",
-      "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
-      "name": "my-openai-connection",
-      "connectionType": "model"
-    }
-    """
-    data = json.loads(json_data, strict=False)
-    instance = FoundryConnection.load(data)
-    assert instance is not None
-    assert instance.kind == "foundry"
-    assert instance.endpoint == "https://myresource.services.ai.azure.com/api/projects/myproject"
-    assert instance.name == "my-openai-connection"
-    assert instance.connectionType == "model"
-
-
-def test_load_yaml_foundryconnection():
-    yaml_data = r"""
-    kind: foundry
-    endpoint: "https://myresource.services.ai.azure.com/api/projects/myproject"
-    name: my-openai-connection
-    connectionType: model
-    
-    """
-    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
-    instance = FoundryConnection.load(data)
-    assert instance is not None
-    assert instance.kind == "foundry"
-    assert instance.endpoint == "https://myresource.services.ai.azure.com/api/projects/myproject"
-    assert instance.name == "my-openai-connection"
-    assert instance.connectionType == "model"
-
-
-def test_roundtrip_json_foundryconnection():
-    """Test that load -> save -> load produces equivalent data."""
-    json_data = r"""
-    {
-      "kind": "foundry",
-      "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
-      "name": "my-openai-connection",
-      "connectionType": "model"
-    }
-    """
-    original_data = json.loads(json_data, strict=False)
-    instance = FoundryConnection.load(original_data)
-    saved_data = instance.save()
-    reloaded = FoundryConnection.load(saved_data)
-    assert reloaded is not None
-    assert reloaded.kind == "foundry"
-    assert reloaded.endpoint == "https://myresource.services.ai.azure.com/api/projects/myproject"
-    assert reloaded.name == "my-openai-connection"
-    assert reloaded.connectionType == "model"
-
-
-def test_to_json_foundryconnection():
-    """Test that to_json produces valid JSON."""
-    json_data = r"""
-    {
-      "kind": "foundry",
-      "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
-      "name": "my-openai-connection",
-      "connectionType": "model"
-    }
-    """
-    data = json.loads(json_data, strict=False)
-    instance = FoundryConnection.load(data)
-    json_output = instance.to_json()
-    assert json_output is not None
-    parsed = json.loads(json_output)
-    assert isinstance(parsed, dict)
-
-
-def test_to_yaml_foundryconnection():
-    """Test that to_yaml produces valid YAML."""
-    json_data = r"""
-    {
-      "kind": "foundry",
-      "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
-      "name": "my-openai-connection",
-      "connectionType": "model"
-    }
-    """
-    data = json.loads(json_data, strict=False)
-    instance = FoundryConnection.load(data)
-    yaml_output = instance.to_yaml()
-    assert yaml_output is not None
-    parsed = yaml.safe_load(yaml_output)
-    assert isinstance(parsed, dict)
+import json
+
+import yaml
+
+from prompty.model import FoundryConnection
+
+
+def test_load_json_foundryconnection():
+    json_data = r"""
+    {
+      "kind": "foundry",
+      "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
+      "name": "my-openai-connection",
+      "connectionType": "model"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = FoundryConnection.load(data)
+    assert instance is not None
+    assert instance.kind == "foundry"
+    assert instance.endpoint == "https://myresource.services.ai.azure.com/api/projects/myproject"
+    assert instance.name == "my-openai-connection"
+    assert instance.connection_type == "model"
+
+
+def test_load_yaml_foundryconnection():
+    yaml_data = r"""
+    kind: foundry
+    endpoint: "https://myresource.services.ai.azure.com/api/projects/myproject"
+    name: my-openai-connection
+    connectionType: model
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = FoundryConnection.load(data)
+    assert instance is not None
+    assert instance.kind == "foundry"
+    assert instance.endpoint == "https://myresource.services.ai.azure.com/api/projects/myproject"
+    assert instance.name == "my-openai-connection"
+    assert instance.connection_type == "model"
+
+
+def test_roundtrip_json_foundryconnection():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "kind": "foundry",
+      "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
+      "name": "my-openai-connection",
+      "connectionType": "model"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = FoundryConnection.load(original_data)
+    saved_data = instance.save()
+    reloaded = FoundryConnection.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.kind == "foundry"
+    assert reloaded.endpoint == "https://myresource.services.ai.azure.com/api/projects/myproject"
+    assert reloaded.name == "my-openai-connection"
+    assert reloaded.connection_type == "model"
+
+
+def test_to_json_foundryconnection():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "kind": "foundry",
+      "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
+      "name": "my-openai-connection",
+      "connectionType": "model"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = FoundryConnection.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_foundryconnection():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "kind": "foundry",
+      "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
+      "name": "my-openai-connection",
+      "connectionType": "model"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = FoundryConnection.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_function_tool.py b/runtime/python/prompty/tests/model/test_function_tool.py
index ae4aef36..fbecb18f 100644
--- a/runtime/python/prompty/tests/model/test_function_tool.py
+++ b/runtime/python/prompty/tests/model/test_function_tool.py
@@ -30,7 +30,6 @@ def test_load_json_functiontool():
     instance = FunctionTool.load(data)
     assert instance is not None
     assert instance.kind == "function"
-
     assert instance.strict
 
 
@@ -176,7 +175,6 @@ def test_load_json_functiontool_1():
     instance = FunctionTool.load(data)
     assert instance is not None
     assert instance.kind == "function"
-
     assert instance.strict
 
 
diff --git a/runtime/python/prompty/tests/model/test_guardrail_result.py b/runtime/python/prompty/tests/model/test_guardrail_result.py
new file mode 100644
index 00000000..c0ae828d
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_guardrail_result.py
@@ -0,0 +1,105 @@
+import json
+
+import yaml
+
+from prompty.model import GuardrailResult
+
+
+def test_load_json_guardrailresult():
+    json_data = r"""
+    {
+      "allowed": true,
+      "reason": "Content is safe"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = GuardrailResult.load(data)
+    assert instance is not None
+    assert instance.allowed
+    assert instance.reason == "Content is safe"
+
+
+def test_load_yaml_guardrailresult():
+    yaml_data = r"""
+    allowed: true
+    reason: Content is safe
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = GuardrailResult.load(data)
+    assert instance is not None
+    assert instance.allowed
+    assert instance.reason == "Content is safe"
+
+
+def test_roundtrip_json_guardrailresult():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "allowed": true,
+      "reason": "Content is safe"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = GuardrailResult.load(original_data)
+    saved_data = instance.save()
+    reloaded = GuardrailResult.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.allowed
+    assert reloaded.reason == "Content is safe"
+
+
+def test_to_json_guardrailresult():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "allowed": true,
+      "reason": "Content is safe"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = GuardrailResult.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_guardrailresult():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "allowed": true,
+      "reason": "Content is safe"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = GuardrailResult.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
+
+
+def test_factory_rewrite_guardrailresult():
+    """Test that rewrite() factory creates a valid instance."""
+    instance = GuardrailResult.create_rewrite("test")
+    assert instance is not None
+    assert isinstance(instance, GuardrailResult)
+    assert instance.allowed
+
+
+def test_factory_deny_guardrailresult():
+    """Test that deny() factory creates a valid instance."""
+    instance = GuardrailResult.deny("test")
+    assert instance is not None
+    assert isinstance(instance, GuardrailResult)
+    assert not instance.allowed
+
+
+def test_factory_allow_guardrailresult():
+    """Test that allow() factory creates a valid instance."""
+    instance = GuardrailResult.allow()
+    assert instance is not None
+    assert isinstance(instance, GuardrailResult)
+    assert instance.allowed
diff --git a/runtime/python/prompty/tests/model/test_image_part.py b/runtime/python/prompty/tests/model/test_image_part.py
new file mode 100644
index 00000000..97e53a92
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_image_part.py
@@ -0,0 +1,89 @@
+import json
+
+import yaml
+
+from prompty.model import ImagePart
+
+
+def test_load_json_imagepart():
+    json_data = r"""
+    {
+      "source": "https://example.com/image.png",
+      "detail": "auto",
+      "mediaType": "image/png"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ImagePart.load(data)
+    assert instance is not None
+    assert instance.source == "https://example.com/image.png"
+    assert instance.detail == "auto"
+    assert instance.media_type == "image/png"
+
+
+def test_load_yaml_imagepart():
+    yaml_data = r"""
+    source: "https://example.com/image.png"
+    detail: auto
+    mediaType: image/png
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ImagePart.load(data)
+    assert instance is not None
+    assert instance.source == "https://example.com/image.png"
+    assert instance.detail == "auto"
+    assert instance.media_type == "image/png"
+
+
+def test_roundtrip_json_imagepart():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "source": "https://example.com/image.png",
+      "detail": "auto",
+      "mediaType": "image/png"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ImagePart.load(original_data)
+    saved_data = instance.save()
+    reloaded = ImagePart.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.source == "https://example.com/image.png"
+    assert reloaded.detail == "auto"
+    assert reloaded.media_type == "image/png"
+
+
+def test_to_json_imagepart():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "source": "https://example.com/image.png",
+      "detail": "auto",
+      "mediaType": "image/png"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ImagePart.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_imagepart():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "source": "https://example.com/image.png",
+      "detail": "auto",
+      "mediaType": "image/png"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ImagePart.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_mcp_tool.py b/runtime/python/prompty/tests/model/test_mcp_tool.py
index ca3248fa..29583f1b 100644
--- a/runtime/python/prompty/tests/model/test_mcp_tool.py
+++ b/runtime/python/prompty/tests/model/test_mcp_tool.py
@@ -27,8 +27,8 @@ def test_load_json_mcptool():
     instance = McpTool.load(data)
     assert instance is not None
     assert instance.kind == "mcp"
-    assert instance.serverName == "My MCP Server"
-    assert instance.serverDescription == "This tool allows access to MCP services."
+    assert instance.server_name == "My MCP Server"
+    assert instance.server_description == "This tool allows access to MCP services."
 
 
 def test_load_yaml_mcptool():
@@ -49,8 +49,8 @@ def test_load_yaml_mcptool():
     instance = McpTool.load(data)
     assert instance is not None
     assert instance.kind == "mcp"
-    assert instance.serverName == "My MCP Server"
-    assert instance.serverDescription == "This tool allows access to MCP services."
+    assert instance.server_name == "My MCP Server"
+    assert instance.server_description == "This tool allows access to MCP services."
 
 
 def test_roundtrip_json_mcptool():
@@ -78,8 +78,8 @@ def test_roundtrip_json_mcptool():
     reloaded = McpTool.load(saved_data)
     assert reloaded is not None
     assert reloaded.kind == "mcp"
-    assert reloaded.serverName == "My MCP Server"
-    assert reloaded.serverDescription == "This tool allows access to MCP services."
+    assert reloaded.server_name == "My MCP Server"
+    assert reloaded.server_description == "This tool allows access to MCP services."
 
 
 def test_to_json_mcptool():
diff --git a/runtime/python/prompty/tests/model/test_message.py b/runtime/python/prompty/tests/model/test_message.py
new file mode 100644
index 00000000..ac52230a
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_message.py
@@ -0,0 +1,138 @@
+import json
+
+import yaml
+
+from prompty.model import Message
+
+
+def test_load_json_message():
+    json_data = r"""
+    {
+      "role": "user",
+      "parts": [
+        {
+          "kind": "text",
+          "value": "Hello!"
+        }
+      ],
+      "metadata": {
+        "source": "user-input"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = Message.load(data)
+    assert instance is not None
+    assert instance.role == "user"
+
+
+def test_load_yaml_message():
+    yaml_data = r"""
+    role: user
+    parts:
+      - kind: text
+        value: Hello!
+    metadata:
+      source: user-input
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = Message.load(data)
+    assert instance is not None
+    assert instance.role == "user"
+
+
+def test_roundtrip_json_message():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "role": "user",
+      "parts": [
+        {
+          "kind": "text",
+          "value": "Hello!"
+        }
+      ],
+      "metadata": {
+        "source": "user-input"
+      }
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = Message.load(original_data)
+    saved_data = instance.save()
+    reloaded = Message.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.role == "user"
+
+
+def test_to_json_message():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "role": "user",
+      "parts": [
+        {
+          "kind": "text",
+          "value": "Hello!"
+        }
+      ],
+      "metadata": {
+        "source": "user-input"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = Message.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_message():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "role": "user",
+      "parts": [
+        {
+          "kind": "text",
+          "value": "Hello!"
+        }
+      ],
+      "metadata": {
+        "source": "user-input"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = Message.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
+
+
+def test_factory_assistant_message():
+    """Test that assistant() factory creates a valid instance."""
+    instance = Message.assistant("test")
+    assert instance is not None
+    assert isinstance(instance, Message)
+    assert instance.role == "assistant"
+
+
+def test_factory_system_message():
+    """Test that system() factory creates a valid instance."""
+    instance = Message.system("test")
+    assert instance is not None
+    assert isinstance(instance, Message)
+    assert instance.role == "system"
+
+
+def test_factory_user_message():
+    """Test that user() factory creates a valid instance."""
+    instance = Message.user("test")
+    assert instance is not None
+    assert isinstance(instance, Message)
+    assert instance.role == "user"
diff --git a/runtime/python/prompty/tests/model/test_messages_updated_payload.py b/runtime/python/prompty/tests/model/test_messages_updated_payload.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_messages_updated_payload.py
@@ -0,0 +1 @@
+
diff --git a/runtime/python/prompty/tests/model/test_model.py b/runtime/python/prompty/tests/model/test_model.py
index 51fe26d6..d704c191 100644
--- a/runtime/python/prompty/tests/model/test_model.py
+++ b/runtime/python/prompty/tests/model/test_model.py
@@ -28,7 +28,7 @@ def test_load_json_model():
     assert instance is not None
     assert instance.id == "gpt-35-turbo"
     assert instance.provider == "foundry"
-    assert instance.apiType == "chat"
+    assert instance.api_type == "chat"
 
 
 def test_load_yaml_model():
@@ -51,7 +51,7 @@ def test_load_yaml_model():
     assert instance is not None
     assert instance.id == "gpt-35-turbo"
     assert instance.provider == "foundry"
-    assert instance.apiType == "chat"
+    assert instance.api_type == "chat"
 
 
 def test_roundtrip_json_model():
@@ -80,7 +80,7 @@ def test_roundtrip_json_model():
     assert reloaded is not None
     assert reloaded.id == "gpt-35-turbo"
     assert reloaded.provider == "foundry"
-    assert reloaded.apiType == "chat"
+    assert reloaded.api_type == "chat"
 
 
 def test_to_json_model():
diff --git a/runtime/python/prompty/tests/model/test_model_info.py b/runtime/python/prompty/tests/model/test_model_info.py
new file mode 100644
index 00000000..da7b8da7
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_model_info.py
@@ -0,0 +1,144 @@
+import json
+
+import yaml
+
+from prompty.model import ModelInfo
+
+
+def test_load_json_modelinfo():
+    json_data = r"""
+    {
+      "id": "gpt-4o",
+      "displayName": "GPT-4o",
+      "ownedBy": "openai",
+      "contextWindow": 128000,
+      "inputModalities": [
+        "text",
+        "image"
+      ],
+      "outputModalities": [
+        "text"
+      ],
+      "additionalProperties": {
+        "supportsStreaming": true
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ModelInfo.load(data)
+    assert instance is not None
+    assert instance.id == "gpt-4o"
+    assert instance.display_name == "GPT-4o"
+    assert instance.owned_by == "openai"
+    assert instance.context_window == 128000
+
+
+def test_load_yaml_modelinfo():
+    yaml_data = r"""
+    id: gpt-4o
+    displayName: GPT-4o
+    ownedBy: openai
+    contextWindow: 128000
+    inputModalities:
+      - text
+      - image
+    outputModalities:
+      - text
+    additionalProperties:
+      supportsStreaming: true
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ModelInfo.load(data)
+    assert instance is not None
+    assert instance.id == "gpt-4o"
+    assert instance.display_name == "GPT-4o"
+    assert instance.owned_by == "openai"
+    assert instance.context_window == 128000
+
+
+def test_roundtrip_json_modelinfo():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "id": "gpt-4o",
+      "displayName": "GPT-4o",
+      "ownedBy": "openai",
+      "contextWindow": 128000,
+      "inputModalities": [
+        "text",
+        "image"
+      ],
+      "outputModalities": [
+        "text"
+      ],
+      "additionalProperties": {
+        "supportsStreaming": true
+      }
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ModelInfo.load(original_data)
+    saved_data = instance.save()
+    reloaded = ModelInfo.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.id == "gpt-4o"
+    assert reloaded.display_name == "GPT-4o"
+    assert reloaded.owned_by == "openai"
+    assert reloaded.context_window == 128000
+
+
+def test_to_json_modelinfo():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "id": "gpt-4o",
+      "displayName": "GPT-4o",
+      "ownedBy": "openai",
+      "contextWindow": 128000,
+      "inputModalities": [
+        "text",
+        "image"
+      ],
+      "outputModalities": [
+        "text"
+      ],
+      "additionalProperties": {
+        "supportsStreaming": true
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ModelInfo.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_modelinfo():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "id": "gpt-4o",
+      "displayName": "GPT-4o",
+      "ownedBy": "openai",
+      "contextWindow": 128000,
+      "inputModalities": [
+        "text",
+        "image"
+      ],
+      "outputModalities": [
+        "text"
+      ],
+      "additionalProperties": {
+        "supportsStreaming": true
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ModelInfo.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_model_options.py b/runtime/python/prompty/tests/model/test_model_options.py
index 553f863c..37ee578e 100644
--- a/runtime/python/prompty/tests/model/test_model_options.py
+++ b/runtime/python/prompty/tests/model/test_model_options.py
@@ -29,15 +29,14 @@ def test_load_json_modeloptions():
     data = json.loads(json_data, strict=False)
     instance = ModelOptions.load(data)
     assert instance is not None
-    assert instance.frequencyPenalty == 0.5
-    assert instance.maxOutputTokens == 2048
-    assert instance.presencePenalty == 0.3
+    assert instance.frequency_penalty == 0.5
+    assert instance.max_output_tokens == 2048
+    assert instance.presence_penalty == 0.3
     assert instance.seed == 42
     assert instance.temperature == 0.7
-    assert instance.topK == 40
-    assert instance.topP == 0.9
-
-    assert instance.allowMultipleToolCalls
+    assert instance.top_k == 40
+    assert instance.top_p == 0.9
+    assert instance.allow_multiple_tool_calls
 
 
 def test_load_yaml_modeloptions():
@@ -61,14 +60,14 @@ def test_load_yaml_modeloptions():
     data = yaml.load(yaml_data, Loader=yaml.FullLoader)
     instance = ModelOptions.load(data)
     assert instance is not None
-    assert instance.frequencyPenalty == 0.5
-    assert instance.maxOutputTokens == 2048
-    assert instance.presencePenalty == 0.3
+    assert instance.frequency_penalty == 0.5
+    assert instance.max_output_tokens == 2048
+    assert instance.presence_penalty == 0.3
     assert instance.seed == 42
     assert instance.temperature == 0.7
-    assert instance.topK == 40
-    assert instance.topP == 0.9
-    assert instance.allowMultipleToolCalls
+    assert instance.top_k == 40
+    assert instance.top_p == 0.9
+    assert instance.allow_multiple_tool_calls
 
 
 def test_roundtrip_json_modeloptions():
@@ -98,14 +97,14 @@ def test_roundtrip_json_modeloptions():
     saved_data = instance.save()
     reloaded = ModelOptions.load(saved_data)
     assert reloaded is not None
-    assert reloaded.frequencyPenalty == 0.5
-    assert reloaded.maxOutputTokens == 2048
-    assert reloaded.presencePenalty == 0.3
+    assert reloaded.frequency_penalty == 0.5
+    assert reloaded.max_output_tokens == 2048
+    assert reloaded.presence_penalty == 0.3
     assert reloaded.seed == 42
     assert reloaded.temperature == 0.7
-    assert reloaded.topK == 40
-    assert reloaded.topP == 0.9
-    assert reloaded.allowMultipleToolCalls
+    assert reloaded.top_k == 40
+    assert reloaded.top_p == 0.9
+    assert reloaded.allow_multiple_tool_calls
 
 
 def test_to_json_modeloptions():
diff --git a/runtime/python/prompty/tests/model/test_o_auth_connection.py b/runtime/python/prompty/tests/model/test_o_auth_connection.py
index cf46b761..d00be0da 100644
--- a/runtime/python/prompty/tests/model/test_o_auth_connection.py
+++ b/runtime/python/prompty/tests/model/test_o_auth_connection.py
@@ -23,9 +23,9 @@ def test_load_json_oauthconnection():
     assert instance is not None
     assert instance.kind == "oauth"
     assert instance.endpoint == "https://api.example.com"
-    assert instance.clientId == "your-client-id"
-    assert instance.clientSecret == "your-client-secret"
-    assert instance.tokenUrl == "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
+    assert instance.client_id == "your-client-id"
+    assert instance.client_secret == "your-client-secret"
+    assert instance.token_url == "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
 
 
 def test_load_yaml_oauthconnection():
@@ -44,9 +44,9 @@ def test_load_yaml_oauthconnection():
     assert instance is not None
     assert instance.kind == "oauth"
     assert instance.endpoint == "https://api.example.com"
-    assert instance.clientId == "your-client-id"
-    assert instance.clientSecret == "your-client-secret"
-    assert instance.tokenUrl == "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
+    assert instance.client_id == "your-client-id"
+    assert instance.client_secret == "your-client-secret"
+    assert instance.token_url == "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
 
 
 def test_roundtrip_json_oauthconnection():
@@ -70,9 +70,9 @@ def test_roundtrip_json_oauthconnection():
     assert reloaded is not None
     assert reloaded.kind == "oauth"
     assert reloaded.endpoint == "https://api.example.com"
-    assert reloaded.clientId == "your-client-id"
-    assert reloaded.clientSecret == "your-client-secret"
-    assert reloaded.tokenUrl == "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
+    assert reloaded.client_id == "your-client-id"
+    assert reloaded.client_secret == "your-client-secret"
+    assert reloaded.token_url == "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
 
 
 def test_to_json_oauthconnection():
diff --git a/runtime/python/prompty/tests/model/test_prompty.py b/runtime/python/prompty/tests/model/test_prompty.py
index f5ecabae..997af6e1 100644
--- a/runtime/python/prompty/tests/model/test_prompty.py
+++ b/runtime/python/prompty/tests/model/test_prompty.py
@@ -77,7 +77,7 @@ def test_load_json_prompty():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -167,7 +167,7 @@ def test_load_yaml_prompty():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -260,7 +260,7 @@ def test_roundtrip_json_prompty():
     reloaded = Prompty.load(saved_data)
     assert reloaded is not None
     assert reloaded.name == "basic-prompt"
-    assert reloaded.displayName == "Basic Prompt"
+    assert reloaded.display_name == "Basic Prompt"
     assert reloaded.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         reloaded.instructions
@@ -503,7 +503,7 @@ def test_load_json_prompty_1():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -593,7 +593,7 @@ def test_load_yaml_prompty_1():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -685,7 +685,7 @@ def test_roundtrip_json_prompty_1():
     reloaded = Prompty.load(saved_data)
     assert reloaded is not None
     assert reloaded.name == "basic-prompt"
-    assert reloaded.displayName == "Basic Prompt"
+    assert reloaded.display_name == "Basic Prompt"
     assert reloaded.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         reloaded.instructions
@@ -928,7 +928,7 @@ def test_load_json_prompty_2():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -1018,7 +1018,7 @@ def test_load_yaml_prompty_2():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -1112,7 +1112,7 @@ def test_roundtrip_json_prompty_2():
     reloaded = Prompty.load(saved_data)
     assert reloaded is not None
     assert reloaded.name == "basic-prompt"
-    assert reloaded.displayName == "Basic Prompt"
+    assert reloaded.display_name == "Basic Prompt"
     assert reloaded.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         reloaded.instructions
@@ -1358,7 +1358,7 @@ def test_load_json_prompty_3():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -1448,7 +1448,7 @@ def test_load_yaml_prompty_3():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -1541,7 +1541,7 @@ def test_roundtrip_json_prompty_3():
     reloaded = Prompty.load(saved_data)
     assert reloaded is not None
     assert reloaded.name == "basic-prompt"
-    assert reloaded.displayName == "Basic Prompt"
+    assert reloaded.display_name == "Basic Prompt"
     assert reloaded.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         reloaded.instructions
@@ -1788,7 +1788,7 @@ def test_load_json_prompty_4():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -1878,7 +1878,7 @@ def test_load_yaml_prompty_4():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -1974,7 +1974,7 @@ def test_roundtrip_json_prompty_4():
     reloaded = Prompty.load(saved_data)
     assert reloaded is not None
     assert reloaded.name == "basic-prompt"
-    assert reloaded.displayName == "Basic Prompt"
+    assert reloaded.display_name == "Basic Prompt"
     assert reloaded.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         reloaded.instructions
@@ -2226,7 +2226,7 @@ def test_load_json_prompty_5():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -2316,7 +2316,7 @@ def test_load_yaml_prompty_5():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -2411,7 +2411,7 @@ def test_roundtrip_json_prompty_5():
     reloaded = Prompty.load(saved_data)
     assert reloaded is not None
     assert reloaded.name == "basic-prompt"
-    assert reloaded.displayName == "Basic Prompt"
+    assert reloaded.display_name == "Basic Prompt"
     assert reloaded.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         reloaded.instructions
@@ -2663,7 +2663,7 @@ def test_load_json_prompty_6():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -2753,7 +2753,7 @@ def test_load_yaml_prompty_6():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -2850,7 +2850,7 @@ def test_roundtrip_json_prompty_6():
     reloaded = Prompty.load(saved_data)
     assert reloaded is not None
     assert reloaded.name == "basic-prompt"
-    assert reloaded.displayName == "Basic Prompt"
+    assert reloaded.display_name == "Basic Prompt"
     assert reloaded.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         reloaded.instructions
@@ -3105,7 +3105,7 @@ def test_load_json_prompty_7():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -3195,7 +3195,7 @@ def test_load_yaml_prompty_7():
     instance = Prompty.load(data)
     assert instance is not None
     assert instance.name == "basic-prompt"
-    assert instance.displayName == "Basic Prompt"
+    assert instance.display_name == "Basic Prompt"
     assert instance.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         instance.instructions
@@ -3291,7 +3291,7 @@ def test_roundtrip_json_prompty_7():
     reloaded = Prompty.load(saved_data)
     assert reloaded is not None
     assert reloaded.name == "basic-prompt"
-    assert reloaded.displayName == "Basic Prompt"
+    assert reloaded.display_name == "Basic Prompt"
     assert reloaded.description == "A basic prompt that uses the GPT-3 chat API to answer questions"
     assert (
         reloaded.instructions
diff --git a/runtime/python/prompty/tests/model/test_property.py b/runtime/python/prompty/tests/model/test_property.py
index 25fa9ac1..52a0e219 100644
--- a/runtime/python/prompty/tests/model/test_property.py
+++ b/runtime/python/prompty/tests/model/test_property.py
@@ -27,7 +27,6 @@ def test_load_json_property():
     assert instance.name == "my-input"
     assert instance.kind == "string"
     assert instance.description == "A description of the input property"
-
     assert instance.required
     assert instance.default == "default value"
     assert instance.example == "example value"
diff --git a/runtime/python/prompty/tests/model/test_status_event_payload.py b/runtime/python/prompty/tests/model/test_status_event_payload.py
new file mode 100644
index 00000000..4fd24528
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_status_event_payload.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import StatusEventPayload
+
+
+def test_load_json_statuseventpayload():
+    json_data = r"""
+    {
+      "message": "Starting iteration 3"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = StatusEventPayload.load(data)
+    assert instance is not None
+    assert instance.message == "Starting iteration 3"
+
+
+def test_load_yaml_statuseventpayload():
+    yaml_data = r"""
+    message: Starting iteration 3
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = StatusEventPayload.load(data)
+    assert instance is not None
+    assert instance.message == "Starting iteration 3"
+
+
+def test_roundtrip_json_statuseventpayload():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "message": "Starting iteration 3"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = StatusEventPayload.load(original_data)
+    saved_data = instance.save()
+    reloaded = StatusEventPayload.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.message == "Starting iteration 3"
+
+
+def test_to_json_statuseventpayload():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "message": "Starting iteration 3"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = StatusEventPayload.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_statuseventpayload():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "message": "Starting iteration 3"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = StatusEventPayload.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_stream_chunk.py b/runtime/python/prompty/tests/model/test_stream_chunk.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_stream_chunk.py
@@ -0,0 +1 @@
+
diff --git a/runtime/python/prompty/tests/model/test_text_chunk.py b/runtime/python/prompty/tests/model/test_text_chunk.py
new file mode 100644
index 00000000..54e5bc68
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_text_chunk.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import TextChunk
+
+
+def test_load_json_textchunk():
+    json_data = r"""
+    {
+      "value": "Hello"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TextChunk.load(data)
+    assert instance is not None
+    assert instance.value == "Hello"
+
+
+def test_load_yaml_textchunk():
+    yaml_data = r"""
+    value: Hello
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = TextChunk.load(data)
+    assert instance is not None
+    assert instance.value == "Hello"
+
+
+def test_roundtrip_json_textchunk():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "value": "Hello"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = TextChunk.load(original_data)
+    saved_data = instance.save()
+    reloaded = TextChunk.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.value == "Hello"
+
+
+def test_to_json_textchunk():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "value": "Hello"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TextChunk.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_textchunk():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "value": "Hello"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TextChunk.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_text_part.py b/runtime/python/prompty/tests/model/test_text_part.py
new file mode 100644
index 00000000..b8d22986
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_text_part.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import TextPart
+
+
+def test_load_json_textpart():
+    json_data = r"""
+    {
+      "value": "Hello, world!"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TextPart.load(data)
+    assert instance is not None
+    assert instance.value == "Hello, world!"
+
+
+def test_load_yaml_textpart():
+    yaml_data = r"""
+    value: Hello, world!
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = TextPart.load(data)
+    assert instance is not None
+    assert instance.value == "Hello, world!"
+
+
+def test_roundtrip_json_textpart():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "value": "Hello, world!"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = TextPart.load(original_data)
+    saved_data = instance.save()
+    reloaded = TextPart.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.value == "Hello, world!"
+
+
+def test_to_json_textpart():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "value": "Hello, world!"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TextPart.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_textpart():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "value": "Hello, world!"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TextPart.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_thinking_chunk.py b/runtime/python/prompty/tests/model/test_thinking_chunk.py
new file mode 100644
index 00000000..de449d7d
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_thinking_chunk.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import ThinkingChunk
+
+
+def test_load_json_thinkingchunk():
+    json_data = r"""
+    {
+      "value": "Let me consider..."
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ThinkingChunk.load(data)
+    assert instance is not None
+    assert instance.value == "Let me consider..."
+
+
+def test_load_yaml_thinkingchunk():
+    yaml_data = r"""
+    value: Let me consider...
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ThinkingChunk.load(data)
+    assert instance is not None
+    assert instance.value == "Let me consider..."
+
+
+def test_roundtrip_json_thinkingchunk():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "value": "Let me consider..."
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ThinkingChunk.load(original_data)
+    saved_data = instance.save()
+    reloaded = ThinkingChunk.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.value == "Let me consider..."
+
+
+def test_to_json_thinkingchunk():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "value": "Let me consider..."
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ThinkingChunk.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_thinkingchunk():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "value": "Let me consider..."
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ThinkingChunk.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_thinking_event_payload.py b/runtime/python/prompty/tests/model/test_thinking_event_payload.py
new file mode 100644
index 00000000..06b5e6c9
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_thinking_event_payload.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import ThinkingEventPayload
+
+
+def test_load_json_thinkingeventpayload():
+    json_data = r"""
+    {
+      "token": "Let me consider..."
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ThinkingEventPayload.load(data)
+    assert instance is not None
+    assert instance.token == "Let me consider..."
+
+
+def test_load_yaml_thinkingeventpayload():
+    yaml_data = r"""
+    token: Let me consider...
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ThinkingEventPayload.load(data)
+    assert instance is not None
+    assert instance.token == "Let me consider..."
+
+
+def test_roundtrip_json_thinkingeventpayload():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "token": "Let me consider..."
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ThinkingEventPayload.load(original_data)
+    saved_data = instance.save()
+    reloaded = ThinkingEventPayload.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.token == "Let me consider..."
+
+
+def test_to_json_thinkingeventpayload():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "token": "Let me consider..."
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ThinkingEventPayload.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_thinkingeventpayload():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "token": "Let me consider..."
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ThinkingEventPayload.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_thread_marker.py b/runtime/python/prompty/tests/model/test_thread_marker.py
new file mode 100644
index 00000000..b9a9b20a
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_thread_marker.py
@@ -0,0 +1,81 @@
+import json
+
+import yaml
+
+from prompty.model import ThreadMarker
+
+
+def test_load_json_threadmarker():
+    json_data = r"""
+    {
+      "name": "thread",
+      "kind": "thread"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ThreadMarker.load(data)
+    assert instance is not None
+    assert instance.name == "thread"
+    assert instance.kind == "thread"
+
+
+def test_load_yaml_threadmarker():
+    yaml_data = r"""
+    name: thread
+    kind: thread
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ThreadMarker.load(data)
+    assert instance is not None
+    assert instance.name == "thread"
+    assert instance.kind == "thread"
+
+
+def test_roundtrip_json_threadmarker():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "name": "thread",
+      "kind": "thread"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ThreadMarker.load(original_data)
+    saved_data = instance.save()
+    reloaded = ThreadMarker.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.name == "thread"
+    assert reloaded.kind == "thread"
+
+
+def test_to_json_threadmarker():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "name": "thread",
+      "kind": "thread"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ThreadMarker.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_threadmarker():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "name": "thread",
+      "kind": "thread"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ThreadMarker.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_token_event_payload.py b/runtime/python/prompty/tests/model/test_token_event_payload.py
new file mode 100644
index 00000000..e0e566ef
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_token_event_payload.py
@@ -0,0 +1,73 @@
+import json
+
+import yaml
+
+from prompty.model import TokenEventPayload
+
+
+def test_load_json_tokeneventpayload():
+    json_data = r"""
+    {
+      "token": "Hello"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TokenEventPayload.load(data)
+    assert instance is not None
+    assert instance.token == "Hello"
+
+
+def test_load_yaml_tokeneventpayload():
+    yaml_data = r"""
+    token: Hello
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = TokenEventPayload.load(data)
+    assert instance is not None
+    assert instance.token == "Hello"
+
+
+def test_roundtrip_json_tokeneventpayload():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "token": "Hello"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = TokenEventPayload.load(original_data)
+    saved_data = instance.save()
+    reloaded = TokenEventPayload.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.token == "Hello"
+
+
+def test_to_json_tokeneventpayload():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "token": "Hello"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TokenEventPayload.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_tokeneventpayload():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "token": "Hello"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TokenEventPayload.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_token_usage.py b/runtime/python/prompty/tests/model/test_token_usage.py
new file mode 100644
index 00000000..458c67ae
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_token_usage.py
@@ -0,0 +1,89 @@
+import json
+
+import yaml
+
+from prompty.model import TokenUsage
+
+
+def test_load_json_tokenusage():
+    json_data = r"""
+    {
+      "promptTokens": 150,
+      "completionTokens": 42,
+      "totalTokens": 192
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TokenUsage.load(data)
+    assert instance is not None
+    assert instance.prompt_tokens == 150
+    assert instance.completion_tokens == 42
+    assert instance.total_tokens == 192
+
+
+def test_load_yaml_tokenusage():
+    yaml_data = r"""
+    promptTokens: 150
+    completionTokens: 42
+    totalTokens: 192
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = TokenUsage.load(data)
+    assert instance is not None
+    assert instance.prompt_tokens == 150
+    assert instance.completion_tokens == 42
+    assert instance.total_tokens == 192
+
+
+def test_roundtrip_json_tokenusage():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "promptTokens": 150,
+      "completionTokens": 42,
+      "totalTokens": 192
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = TokenUsage.load(original_data)
+    saved_data = instance.save()
+    reloaded = TokenUsage.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.prompt_tokens == 150
+    assert reloaded.completion_tokens == 42
+    assert reloaded.total_tokens == 192
+
+
+def test_to_json_tokenusage():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "promptTokens": 150,
+      "completionTokens": 42,
+      "totalTokens": 192
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TokenUsage.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_tokenusage():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "promptTokens": 150,
+      "completionTokens": 42,
+      "totalTokens": 192
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TokenUsage.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_tool_call.py b/runtime/python/prompty/tests/model/test_tool_call.py
new file mode 100644
index 00000000..a7248f51
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_tool_call.py
@@ -0,0 +1,89 @@
+import json
+
+import yaml
+
+from prompty.model import ToolCall
+
+
+def test_load_json_toolcall():
+    json_data = r"""
+    {
+      "id": "call_abc123",
+      "name": "get_weather",
+      "arguments": "{\"city\": \"Paris\"}"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolCall.load(data)
+    assert instance is not None
+    assert instance.id == "call_abc123"
+    assert instance.name == "get_weather"
+    assert instance.arguments == '{"city": "Paris"}'
+
+
+def test_load_yaml_toolcall():
+    yaml_data = r"""
+    id: call_abc123
+    name: get_weather
+    arguments: "{\"city\": \"Paris\"}"
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ToolCall.load(data)
+    assert instance is not None
+    assert instance.id == "call_abc123"
+    assert instance.name == "get_weather"
+    assert instance.arguments == '{"city": "Paris"}'
+
+
+def test_roundtrip_json_toolcall():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "id": "call_abc123",
+      "name": "get_weather",
+      "arguments": "{\"city\": \"Paris\"}"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ToolCall.load(original_data)
+    saved_data = instance.save()
+    reloaded = ToolCall.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.id == "call_abc123"
+    assert reloaded.name == "get_weather"
+    assert reloaded.arguments == '{"city": "Paris"}'
+
+
+def test_to_json_toolcall():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "id": "call_abc123",
+      "name": "get_weather",
+      "arguments": "{\"city\": \"Paris\"}"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolCall.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_toolcall():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "id": "call_abc123",
+      "name": "get_weather",
+      "arguments": "{\"city\": \"Paris\"}"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolCall.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_tool_call_start_payload.py b/runtime/python/prompty/tests/model/test_tool_call_start_payload.py
new file mode 100644
index 00000000..41d57fe5
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_tool_call_start_payload.py
@@ -0,0 +1,81 @@
+import json
+
+import yaml
+
+from prompty.model import ToolCallStartPayload
+
+
+def test_load_json_toolcallstartpayload():
+    json_data = r"""
+    {
+      "name": "get_weather",
+      "arguments": "{\"city\": \"Paris\"}"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolCallStartPayload.load(data)
+    assert instance is not None
+    assert instance.name == "get_weather"
+    assert instance.arguments == '{"city": "Paris"}'
+
+
+def test_load_yaml_toolcallstartpayload():
+    yaml_data = r"""
+    name: get_weather
+    arguments: "{\"city\": \"Paris\"}"
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ToolCallStartPayload.load(data)
+    assert instance is not None
+    assert instance.name == "get_weather"
+    assert instance.arguments == '{"city": "Paris"}'
+
+
+def test_roundtrip_json_toolcallstartpayload():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "name": "get_weather",
+      "arguments": "{\"city\": \"Paris\"}"
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ToolCallStartPayload.load(original_data)
+    saved_data = instance.save()
+    reloaded = ToolCallStartPayload.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.name == "get_weather"
+    assert reloaded.arguments == '{"city": "Paris"}'
+
+
+def test_to_json_toolcallstartpayload():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "name": "get_weather",
+      "arguments": "{\"city\": \"Paris\"}"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolCallStartPayload.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_toolcallstartpayload():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "name": "get_weather",
+      "arguments": "{\"city\": \"Paris\"}"
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolCallStartPayload.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_tool_chunk.py b/runtime/python/prompty/tests/model/test_tool_chunk.py
new file mode 100644
index 00000000..670e143c
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_tool_chunk.py
@@ -0,0 +1,89 @@
+import json
+
+import yaml
+
+from prompty.model import ToolChunk
+
+
+def test_load_json_toolchunk():
+    json_data = r"""
+    {
+      "toolCall": {
+        "id": "call_abc123",
+        "name": "get_weather",
+        "arguments": "{\"city\": \"Paris\"}"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolChunk.load(data)
+    assert instance is not None
+
+
+def test_load_yaml_toolchunk():
+    yaml_data = r"""
+    toolCall:
+      id: call_abc123
+      name: get_weather
+      arguments: "{\"city\": \"Paris\"}"
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ToolChunk.load(data)
+    assert instance is not None
+
+
+def test_roundtrip_json_toolchunk():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "toolCall": {
+        "id": "call_abc123",
+        "name": "get_weather",
+        "arguments": "{\"city\": \"Paris\"}"
+      }
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ToolChunk.load(original_data)
+    saved_data = instance.save()
+    reloaded = ToolChunk.load(saved_data)
+    assert reloaded is not None
+
+
+def test_to_json_toolchunk():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "toolCall": {
+        "id": "call_abc123",
+        "name": "get_weather",
+        "arguments": "{\"city\": \"Paris\"}"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolChunk.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_toolchunk():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "toolCall": {
+        "id": "call_abc123",
+        "name": "get_weather",
+        "arguments": "{\"city\": \"Paris\"}"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolChunk.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_tool_context.py b/runtime/python/prompty/tests/model/test_tool_context.py
new file mode 100644
index 00000000..4a7c8552
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_tool_context.py
@@ -0,0 +1,79 @@
+import json
+
+import yaml
+
+from prompty.model import ToolContext
+
+
+def test_load_json_toolcontext():
+    json_data = r"""
+    {
+      "metadata": {
+        "userId": "user-123"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolContext.load(data)
+    assert instance is not None
+
+
+def test_load_yaml_toolcontext():
+    yaml_data = r"""
+    metadata:
+      userId: user-123
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ToolContext.load(data)
+    assert instance is not None
+
+
+def test_roundtrip_json_toolcontext():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "metadata": {
+        "userId": "user-123"
+      }
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ToolContext.load(original_data)
+    saved_data = instance.save()
+    reloaded = ToolContext.load(saved_data)
+    assert reloaded is not None
+
+
+def test_to_json_toolcontext():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "metadata": {
+        "userId": "user-123"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolContext.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_toolcontext():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "metadata": {
+        "userId": "user-123"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolContext.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_tool_dispatch_result.py b/runtime/python/prompty/tests/model/test_tool_dispatch_result.py
new file mode 100644
index 00000000..0d8f7ca6
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_tool_dispatch_result.py
@@ -0,0 +1,117 @@
+import json
+
+import yaml
+
+from prompty.model import ToolDispatchResult
+
+
+def test_load_json_tooldispatchresult():
+    json_data = r"""
+    {
+      "toolCallId": "call_abc123",
+      "name": "get_weather",
+      "result": {
+        "parts": [
+          {
+            "kind": "text",
+            "value": "72°F and sunny"
+          }
+        ]
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolDispatchResult.load(data)
+    assert instance is not None
+    assert instance.tool_call_id == "call_abc123"
+    assert instance.name == "get_weather"
+
+
+def test_load_yaml_tooldispatchresult():
+    yaml_data = r"""
+    toolCallId: call_abc123
+    name: get_weather
+    result:
+      parts:
+        - kind: text
+          value: 72°F and sunny
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ToolDispatchResult.load(data)
+    assert instance is not None
+    assert instance.tool_call_id == "call_abc123"
+    assert instance.name == "get_weather"
+
+
+def test_roundtrip_json_tooldispatchresult():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "toolCallId": "call_abc123",
+      "name": "get_weather",
+      "result": {
+        "parts": [
+          {
+            "kind": "text",
+            "value": "72°F and sunny"
+          }
+        ]
+      }
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ToolDispatchResult.load(original_data)
+    saved_data = instance.save()
+    reloaded = ToolDispatchResult.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.tool_call_id == "call_abc123"
+    assert reloaded.name == "get_weather"
+
+
+def test_to_json_tooldispatchresult():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "toolCallId": "call_abc123",
+      "name": "get_weather",
+      "result": {
+        "parts": [
+          {
+            "kind": "text",
+            "value": "72°F and sunny"
+          }
+        ]
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolDispatchResult.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_tooldispatchresult():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "toolCallId": "call_abc123",
+      "name": "get_weather",
+      "result": {
+        "parts": [
+          {
+            "kind": "text",
+            "value": "72°F and sunny"
+          }
+        ]
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolDispatchResult.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_tool_result.py b/runtime/python/prompty/tests/model/test_tool_result.py
new file mode 100644
index 00000000..1717e47d
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_tool_result.py
@@ -0,0 +1,99 @@
+import json
+
+import yaml
+
+from prompty.model import ToolResult
+
+
+def test_load_json_toolresult():
+    json_data = r"""
+    {
+      "parts": [
+        {
+          "kind": "text",
+          "value": "72°F and sunny"
+        }
+      ]
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolResult.load(data)
+    assert instance is not None
+
+
+def test_load_yaml_toolresult():
+    yaml_data = r"""
+    parts:
+      - kind: text
+        value: 72°F and sunny
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ToolResult.load(data)
+    assert instance is not None
+
+
+def test_roundtrip_json_toolresult():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "parts": [
+        {
+          "kind": "text",
+          "value": "72°F and sunny"
+        }
+      ]
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ToolResult.load(original_data)
+    saved_data = instance.save()
+    reloaded = ToolResult.load(saved_data)
+    assert reloaded is not None
+
+
+def test_to_json_toolresult():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "parts": [
+        {
+          "kind": "text",
+          "value": "72°F and sunny"
+        }
+      ]
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolResult.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_toolresult():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "parts": [
+        {
+          "kind": "text",
+          "value": "72°F and sunny"
+        }
+      ]
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolResult.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
+
+
+def test_factory_text_toolresult():
+    """Test that text() factory creates a valid instance."""
+    instance = ToolResult.text("test")
+    assert instance is not None
+    assert isinstance(instance, ToolResult)
diff --git a/runtime/python/prompty/tests/model/test_tool_result_payload.py b/runtime/python/prompty/tests/model/test_tool_result_payload.py
new file mode 100644
index 00000000..31eac0d1
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_tool_result_payload.py
@@ -0,0 +1,109 @@
+import json
+
+import yaml
+
+from prompty.model import ToolResultPayload
+
+
+def test_load_json_toolresultpayload():
+    json_data = r"""
+    {
+      "name": "get_weather",
+      "result": {
+        "parts": [
+          {
+            "kind": "text",
+            "value": "72°F and sunny"
+          }
+        ]
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolResultPayload.load(data)
+    assert instance is not None
+    assert instance.name == "get_weather"
+
+
+def test_load_yaml_toolresultpayload():
+    yaml_data = r"""
+    name: get_weather
+    result:
+      parts:
+        - kind: text
+          value: 72°F and sunny
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = ToolResultPayload.load(data)
+    assert instance is not None
+    assert instance.name == "get_weather"
+
+
+def test_roundtrip_json_toolresultpayload():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "name": "get_weather",
+      "result": {
+        "parts": [
+          {
+            "kind": "text",
+            "value": "72°F and sunny"
+          }
+        ]
+      }
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = ToolResultPayload.load(original_data)
+    saved_data = instance.save()
+    reloaded = ToolResultPayload.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.name == "get_weather"
+
+
+def test_to_json_toolresultpayload():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "name": "get_weather",
+      "result": {
+        "parts": [
+          {
+            "kind": "text",
+            "value": "72°F and sunny"
+          }
+        ]
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolResultPayload.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_toolresultpayload():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "name": "get_weather",
+      "result": {
+        "parts": [
+          {
+            "kind": "text",
+            "value": "72°F and sunny"
+          }
+        ]
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = ToolResultPayload.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/model/test_turn_options.py b/runtime/python/prompty/tests/model/test_turn_options.py
new file mode 100644
index 00000000..8045097d
--- /dev/null
+++ b/runtime/python/prompty/tests/model/test_turn_options.py
@@ -0,0 +1,127 @@
+import json
+
+import yaml
+
+from prompty.model import TurnOptions
+
+
+def test_load_json_turnoptions():
+    json_data = r"""
+    {
+      "maxIterations": 10,
+      "maxLlmRetries": 3,
+      "contextBudget": 100000,
+      "parallelToolCalls": true,
+      "raw": false,
+      "turn": 1,
+      "compaction": {
+        "strategy": "summarize"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TurnOptions.load(data)
+    assert instance is not None
+    assert instance.max_iterations == 10
+    assert instance.max_llm_retries == 3
+    assert instance.context_budget == 100000
+    assert instance.parallel_tool_calls
+    assert not instance.raw
+    assert instance.turn == 1
+
+
+def test_load_yaml_turnoptions():
+    yaml_data = r"""
+    maxIterations: 10
+    maxLlmRetries: 3
+    contextBudget: 100000
+    parallelToolCalls: true
+    raw: false
+    turn: 1
+    compaction:
+      strategy: summarize
+    
+    """
+    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
+    instance = TurnOptions.load(data)
+    assert instance is not None
+    assert instance.max_iterations == 10
+    assert instance.max_llm_retries == 3
+    assert instance.context_budget == 100000
+    assert instance.parallel_tool_calls
+    assert not instance.raw
+    assert instance.turn == 1
+
+
+def test_roundtrip_json_turnoptions():
+    """Test that load -> save -> load produces equivalent data."""
+    json_data = r"""
+    {
+      "maxIterations": 10,
+      "maxLlmRetries": 3,
+      "contextBudget": 100000,
+      "parallelToolCalls": true,
+      "raw": false,
+      "turn": 1,
+      "compaction": {
+        "strategy": "summarize"
+      }
+    }
+    """
+    original_data = json.loads(json_data, strict=False)
+    instance = TurnOptions.load(original_data)
+    saved_data = instance.save()
+    reloaded = TurnOptions.load(saved_data)
+    assert reloaded is not None
+    assert reloaded.max_iterations == 10
+    assert reloaded.max_llm_retries == 3
+    assert reloaded.context_budget == 100000
+    assert reloaded.parallel_tool_calls
+    assert not reloaded.raw
+    assert reloaded.turn == 1
+
+
+def test_to_json_turnoptions():
+    """Test that to_json produces valid JSON."""
+    json_data = r"""
+    {
+      "maxIterations": 10,
+      "maxLlmRetries": 3,
+      "contextBudget": 100000,
+      "parallelToolCalls": true,
+      "raw": false,
+      "turn": 1,
+      "compaction": {
+        "strategy": "summarize"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TurnOptions.load(data)
+    json_output = instance.to_json()
+    assert json_output is not None
+    parsed = json.loads(json_output)
+    assert isinstance(parsed, dict)
+
+
+def test_to_yaml_turnoptions():
+    """Test that to_yaml produces valid YAML."""
+    json_data = r"""
+    {
+      "maxIterations": 10,
+      "maxLlmRetries": 3,
+      "contextBudget": 100000,
+      "parallelToolCalls": true,
+      "raw": false,
+      "turn": 1,
+      "compaction": {
+        "strategy": "summarize"
+      }
+    }
+    """
+    data = json.loads(json_data, strict=False)
+    instance = TurnOptions.load(data)
+    yaml_output = instance.to_yaml()
+    assert yaml_output is not None
+    parsed = yaml.safe_load(yaml_output)
+    assert isinstance(parsed, dict)
diff --git a/runtime/python/prompty/tests/test_anthropic.py b/runtime/python/prompty/tests/test_anthropic.py
index 1023bf9c..136ab6f4 100644
--- a/runtime/python/prompty/tests/test_anthropic.py
+++ b/runtime/python/prompty/tests/test_anthropic.py
@@ -570,7 +570,7 @@ def test_load_chat_prompty(self):
 
         agent = load(PROMPTS_DIR / "anthropic_chat.prompty")
         assert agent.model.provider == "anthropic"
-        assert agent.model.apiType == "chat"
+        assert agent.model.api_type == "chat"
         assert agent.model.id == "claude-sonnet-4-5-20250929"
 
     def test_load_tools_prompty(self):
diff --git a/runtime/python/prompty/tests/test_loader.py b/runtime/python/prompty/tests/test_loader.py
index d4a8cecd..0689593b 100644
--- a/runtime/python/prompty/tests/test_loader.py
+++ b/runtime/python/prompty/tests/test_loader.py
@@ -117,7 +117,7 @@ def test_load_model_full(self):
             agent = load(PROMPTS / "basic.prompty")
             assert agent.model.id == "gpt-4"
             assert agent.model.provider == "foundry"
-            assert agent.model.apiType == "chat"
+            assert agent.model.api_type == "chat"
         finally:
             del os.environ["AZURE_OPENAI_ENDPOINT"]
             del os.environ["AZURE_OPENAI_API_KEY"]
@@ -131,7 +131,7 @@ def test_load_model_connection(self):
             conn = agent.model.connection
             assert isinstance(conn, ApiKeyConnection)
             assert conn.endpoint == "https://test.openai.azure.com/"
-            assert conn.apiKey == "test-key-123"
+            assert conn.api_key == "test-key-123"
         finally:
             del os.environ["AZURE_OPENAI_ENDPOINT"]
             del os.environ["AZURE_OPENAI_API_KEY"]
@@ -145,7 +145,7 @@ def test_load_model_options(self):
             opts = agent.model.options
             assert opts is not None
             assert opts.temperature == 0.7
-            assert opts.maxOutputTokens == 1000
+            assert opts.max_output_tokens == 1000
         finally:
             del os.environ["AZURE_OPENAI_ENDPOINT"]
             del os.environ["AZURE_OPENAI_API_KEY"]
@@ -221,7 +221,7 @@ def test_load_tools_mcp(self):
         tool = agent.tools[0]
         assert isinstance(tool, McpTool)
         assert tool.name == "filesystem"
-        assert tool.serverName == "filesystem-server"
+        assert tool.server_name == "filesystem-server"
         assert isinstance(tool.connection, ReferenceConnection)
 
     def test_load_tools_openapi(self):
@@ -300,7 +300,7 @@ def test_load_env_resolution(self):
             conn = agent.model.connection
             assert isinstance(conn, ApiKeyConnection)
             assert conn.endpoint == "https://resolved.openai.azure.com/"
-            assert conn.apiKey == "resolved-key"
+            assert conn.api_key == "resolved-key"
         finally:
             del os.environ["TEST_ENDPOINT"]
             del os.environ["TEST_API_KEY"]
@@ -356,7 +356,7 @@ def test_load_shared_connection(self):
         conn = agent.model.connection
         assert isinstance(conn, ApiKeyConnection)
         assert conn.endpoint == "https://shared.openai.azure.com/"
-        assert conn.apiKey == "shared-key"
+        assert conn.api_key == "shared-key"
 
     def test_load_shared_connection_kind(self):
         """Shared connection resolves to correct kind."""
diff --git a/runtime/python/prompty/tests/test_spec_vectors.py b/runtime/python/prompty/tests/test_spec_vectors.py
index a941acd0..29eba1df 100644
--- a/runtime/python/prompty/tests/test_spec_vectors.py
+++ b/runtime/python/prompty/tests/test_spec_vectors.py
@@ -406,8 +406,8 @@ def _check_model(model: Model, expected: dict, errors: list[str]):
         if model.provider != expected["provider"]:
             errors.append(f"  model.provider: {model.provider!r} != expected {expected['provider']!r}")
     if "apiType" in expected:
-        if model.apiType != expected["apiType"]:
-            errors.append(f"  model.apiType: {model.apiType!r} != expected {expected['apiType']!r}")
+        if model.api_type != expected["apiType"]:
+            errors.append(f"  model.api_type: {model.api_type!r} != expected {expected['apiType']!r}")
     if "connection" in expected and expected["connection"] is not None:
         conn = model.connection
         exp_conn = expected["connection"]
@@ -423,9 +423,9 @@ def _check_model(model: Model, expected: dict, errors: list[str]):
                 if actual_ep != exp_conn["endpoint"]:
                     errors.append(f"  model.connection.endpoint: {actual_ep!r} != expected {exp_conn['endpoint']!r}")
             if "apiKey" in exp_conn:
-                actual_key = getattr(conn, "apiKey", None)
+                actual_key = getattr(conn, "api_key", None)
                 if actual_key != exp_conn["apiKey"]:
-                    errors.append(f"  model.connection.apiKey: {actual_key!r} != expected {exp_conn['apiKey']!r}")
+                    errors.append(f"  model.connection.api_key: {actual_key!r} != expected {exp_conn['apiKey']!r}")
     if "options" in expected and expected["options"] is not None:
         opts = model.options
         exp_opts = expected["options"]
@@ -434,9 +434,9 @@ def _check_model(model: Model, expected: dict, errors: list[str]):
         else:
             if "temperature" in exp_opts and opts.temperature != exp_opts["temperature"]:
                 errors.append(f"  model.options.temperature: {opts.temperature} != {exp_opts['temperature']}")
-            if "maxOutputTokens" in exp_opts and opts.maxOutputTokens != exp_opts["maxOutputTokens"]:
+            if "maxOutputTokens" in exp_opts and opts.max_output_tokens != exp_opts["maxOutputTokens"]:
                 errors.append(
-                    f"  model.options.maxOutputTokens: {opts.maxOutputTokens} != {exp_opts['maxOutputTokens']}"
+                    f"  model.options.max_output_tokens: {opts.max_output_tokens} != {exp_opts['maxOutputTokens']}"
                 )
 
 
@@ -478,9 +478,9 @@ def _check_tools(actual: list, expected: list[dict], errors: list[str]):
             act_params = getattr(act, "parameters", []) or []
             _check_properties(act_params, exp["parameters"], f"{prefix}.parameters", errors)
         if "serverName" in exp:
-            act_val = getattr(act, "serverName", None)
+            act_val = getattr(act, "server_name", None)
             if act_val != exp["serverName"]:
-                errors.append(f"  {prefix}.serverName: {act_val!r} != expected {exp['serverName']!r}")
+                errors.append(f"  {prefix}.server_name: {act_val!r} != expected {exp['serverName']!r}")
         if "specification" in exp:
             act_val = getattr(act, "specification", None)
             if act_val != exp["specification"]:
diff --git a/runtime/python/prompty/tests/test_structured.py b/runtime/python/prompty/tests/test_structured.py
index 7966e93c..44f34222 100644
--- a/runtime/python/prompty/tests/test_structured.py
+++ b/runtime/python/prompty/tests/test_structured.py
@@ -199,7 +199,7 @@ def test_openai_processor_returns_structured_result_on_chat(self):
         agent = MagicMock()
         agent.outputs = [MagicMock()]
         agent.model = MagicMock()
-        agent.model.apiType = "chat"
+        agent.model.api_type = "chat"
 
         # Create a mock ChatCompletion
         mock_choice = MagicMock()
diff --git a/runtime/rust/prompty-anthropic/src/wire.rs b/runtime/rust/prompty-anthropic/src/wire.rs
index 95ebf960..92dbe27a 100644
--- a/runtime/rust/prompty-anthropic/src/wire.rs
+++ b/runtime/rust/prompty-anthropic/src/wire.rs
@@ -193,28 +193,46 @@ fn part_to_wire(part: &ContentPart) -> Value {
 // Options
 // ---------------------------------------------------------------------------
 
+/// Fix f32 precision artifacts in a JSON value.
+/// serde_json serializes f32 via f64, causing 0.1 → 0.10000000149011612.
+/// Round-trip through f32 display to get a clean decimal representation.
+fn fix_f32_value(v: Value) -> Value {
+    if v.is_f64() {
+        if let Some(f) = v.as_f64() {
+            let s = format!("{}", f as f32);
+            let clean: f64 = s.parse().unwrap_or(f);
+            return json!(clean);
+        }
+    }
+    v
+}
+
 /// Apply model options to the request body.
 fn apply_options(agent: &Prompty, body: &mut Map<String, Value>) {
     let mut max_tokens = DEFAULT_MAX_TOKENS;
 
     if let Some(opts) = &agent.model.options {
-        if let Some(v) = opts.temperature {
-            body.insert("temperature".into(), f32_to_json(v));
-        }
-        if let Some(v) = opts.top_p {
-            body.insert("top_p".into(), f32_to_json(v));
-        }
-        if let Some(v) = opts.top_k {
-            body.insert("top_k".into(), json!(v));
-        }
-        if let Some(v) = opts.max_output_tokens {
-            max_tokens = v as i64;
-        }
-        if let Some(ref seqs) = opts.stop_sequences {
-            body.insert("stop_sequences".into(), json!(seqs));
+        let wire = opts.to_wire("anthropic");
+        if let Value::Object(map) = wire {
+            for (k, v) in map {
+                if v.is_null() {
+                    continue;
+                }
+                if k == "max_tokens" {
+                    max_tokens = v.as_i64().unwrap_or(DEFAULT_MAX_TOKENS);
+                } else {
+                    body.insert(k, fix_f32_value(v));
+                }
+            }
         }
-        if let Some(v) = opts.seed {
-            body.insert("seed".into(), json!(v));
+
+        // additionalProperties — merge any extra keys
+        if let Some(map) = opts.additional_properties.as_object() {
+            for (k, v) in map {
+                if !body.contains_key(k) {
+                    body.insert(k.clone(), v.clone());
+                }
+            }
         }
     }
 
@@ -222,14 +240,6 @@ fn apply_options(agent: &Prompty, body: &mut Map<String, Value>) {
     body.insert("max_tokens".into(), json!(max_tokens));
 }
 
-/// Convert f32 to JSON Value without precision artifacts.
-/// f32 0.1 → "0.1" not "0.10000000149011612"
-fn f32_to_json(v: f32) -> Value {
-    let s = format!("{}", v);
-    let f: f64 = s.parse().unwrap_or(v as f64);
-    json!(f)
-}
-
 // ---------------------------------------------------------------------------
 // Structured output (outputSchema → output_config)
 // ---------------------------------------------------------------------------
@@ -246,7 +256,7 @@ fn output_schema_to_wire(agent: &Prompty) -> Option<Value> {
     let mut properties = Map::new();
     let mut required = Vec::new();
 
-    for prop in &outputs {
+    for prop in outputs {
         let kind_str = prop.kind_str();
         let json_type = match kind_str {
             "float" | "number" => "number",
@@ -341,16 +351,14 @@ fn property_to_json_schema(prop: &Property) -> Value {
             }
         }
         PropertyKind::Object { properties } => {
-            if let Some(arr) = properties.as_array() {
-                let ctx = prompty::model::context::LoadContext::default();
+            if !properties.is_empty() {
                 let mut nested = Map::new();
                 let mut req = Vec::new();
-                for val in arr {
-                    let p = Property::load_from_value(val, &ctx);
+                for p in properties {
                     if p.name.is_empty() {
                         continue;
                     }
-                    nested.insert(p.name.clone(), property_to_json_schema(&p));
+                    nested.insert(p.name.clone(), property_to_json_schema(p));
                     req.push(json!(p.name));
                 }
                 schema.insert("properties".into(), Value::Object(nested));
@@ -367,23 +375,12 @@ fn property_to_json_schema(prop: &Property) -> Value {
     Value::Object(schema)
 }
 
-/// Convert tool parameters (stored as serde_json::Value) to JSON Schema for `input_schema`.
-fn parameters_to_json_schema(params_value: &Value) -> Value {
-    use prompty::model::context::LoadContext;
-
-    let ctx = LoadContext::default();
-    let params: Vec<Property> = if let Some(arr) = params_value.as_array() {
-        arr.iter()
-            .map(|v| Property::load_from_value(v, &ctx))
-            .collect()
-    } else {
-        return json!({"type": "object", "properties": {}});
-    };
-
+/// Convert tool parameters to JSON Schema for `input_schema`.
+fn parameters_to_json_schema(params: &[Property]) -> Value {
     let mut properties = Map::new();
     let mut required = Vec::new();
 
-    for param in &params {
+    for param in params {
         properties.insert(param.name.clone(), property_to_json_schema(param));
         if param.required.unwrap_or(false) {
             required.push(json!(param.name));
diff --git a/runtime/rust/prompty-openai/src/wire.rs b/runtime/rust/prompty-openai/src/wire.rs
index 12564264..0810590b 100644
--- a/runtime/rust/prompty-openai/src/wire.rs
+++ b/runtime/rust/prompty-openai/src/wire.rs
@@ -201,38 +201,30 @@ fn extract_text_input(messages: &[Message]) -> Value {
 // Options mapping
 // ---------------------------------------------------------------------------
 
-/// Convert f32 to JSON Value without precision artifacts.
-/// f32 0.1 → "0.1" not "0.10000000149011612"
-fn f32_to_json(v: f32) -> Value {
-    // Round-trip through string to get clean decimal representation
-    let s = format!("{}", v);
-    let f: f64 = s.parse().unwrap_or(v as f64);
-    json!(f)
+/// Fix f32 precision artifacts in a JSON value.
+/// serde_json serializes f32 via f64, causing 0.1 → 0.10000000149011612.
+/// Round-trip through f32 display to get a clean decimal representation.
+fn fix_f32_value(v: Value) -> Value {
+    if v.is_f64() {
+        if let Some(f) = v.as_f64() {
+            let s = format!("{}", f as f32);
+            let clean: f64 = s.parse().unwrap_or(f);
+            return json!(clean);
+        }
+    }
+    v
 }
 
 fn apply_options(args: &mut Map<String, Value>, opts: &Option<ModelOptions>) {
     let Some(opts) = opts else { return };
 
-    if let Some(t) = opts.temperature {
-        args.insert("temperature".to_string(), f32_to_json(t));
-    }
-    if let Some(m) = opts.max_output_tokens {
-        args.insert("max_completion_tokens".to_string(), json!(m));
-    }
-    if let Some(p) = opts.top_p {
-        args.insert("top_p".to_string(), f32_to_json(p));
-    }
-    if let Some(f) = opts.frequency_penalty {
-        args.insert("frequency_penalty".to_string(), f32_to_json(f));
-    }
-    if let Some(p) = opts.presence_penalty {
-        args.insert("presence_penalty".to_string(), f32_to_json(p));
-    }
-    if let Some(s) = opts.seed {
-        args.insert("seed".to_string(), json!(s));
-    }
-    if let Some(ref stop) = opts.stop_sequences {
-        args.insert("stop".to_string(), json!(stop));
+    let wire = opts.to_wire("openai");
+    if let Value::Object(map) = wire {
+        for (k, v) in map {
+            if !v.is_null() {
+                args.insert(k, fix_f32_value(v));
+            }
+        }
     }
 
     // additionalProperties — merge any extra keys
@@ -277,19 +269,15 @@ fn function_tool_to_wire(tool: &Tool) -> Value {
 
     // Collect bound parameter names to strip from wire format (§7.1.3)
     let bound_names: std::collections::HashSet<String> = tool
-        .as_bindings()
-        .unwrap_or_default()
+        .bindings
         .iter()
         .map(|b| b.name.clone())
         .collect();
 
     // Parameters → JSON Schema, filtering out bound params
-    if let Some(params) = parameters.as_array() {
-        use prompty::model::context::LoadContext;
-        let ctx = LoadContext::default();
-        let typed_params: Vec<Property> = params
+    {
+        let typed_params: Vec<&Property> = parameters
             .iter()
-            .map(|v| Property::load_from_value(v, &ctx))
             .filter(|p| !bound_names.contains(&p.name))
             .collect();
         let schema = parameters_to_json_schema(&typed_params);
@@ -336,23 +324,19 @@ fn property_to_json_schema(prop: &Property) -> Value {
             // When items is null/unspecified, emit bare {"type": "array"}
         }
         PropertyKind::Object { properties } => {
-            if let Some(arr) = properties.as_array() {
-                if !arr.is_empty() {
-                    let ctx = prompty::model::context::LoadContext::default();
-                    let mut nested = Map::new();
-                    let mut req = Vec::new();
-                    for val in arr {
-                        let p = Property::load_from_value(val, &ctx);
-                        if p.name.is_empty() {
-                            continue;
-                        }
-                        nested.insert(p.name.clone(), property_to_json_schema(&p));
-                        req.push(Value::String(p.name.clone()));
+            if !properties.is_empty() {
+                let mut nested = Map::new();
+                let mut req = Vec::new();
+                for p in properties {
+                    if p.name.is_empty() {
+                        continue;
                     }
-                    schema.insert("properties".to_string(), Value::Object(nested));
-                    schema.insert("required".to_string(), Value::Array(req));
-                    schema.insert("additionalProperties".to_string(), Value::Bool(false));
+                    nested.insert(p.name.clone(), property_to_json_schema(p));
+                    req.push(Value::String(p.name.clone()));
                 }
+                schema.insert("properties".to_string(), Value::Object(nested));
+                schema.insert("required".to_string(), Value::Array(req));
+                schema.insert("additionalProperties".to_string(), Value::Bool(false));
             }
             // When properties is empty or absent, emit bare {"type": "object"}
         }
@@ -362,7 +346,7 @@ fn property_to_json_schema(prop: &Property) -> Value {
     Value::Object(schema)
 }
 
-fn parameters_to_json_schema(params: &[Property]) -> Value {
+fn parameters_to_json_schema(params: &[&Property]) -> Value {
     let mut properties = Map::new();
     let mut required = Vec::new();
 
@@ -408,7 +392,7 @@ fn output_schema_to_wire(agent: &Prompty) -> Option<Value> {
     let mut properties = Map::new();
     let mut required = Vec::new();
 
-    for prop in &outputs {
+    for prop in outputs {
         properties.insert(prop.name.clone(), property_to_json_schema(prop));
         if prop.required.unwrap_or(false) {
             required.push(Value::String(prop.name.clone()));
@@ -524,14 +508,13 @@ fn message_to_responses_input(msg: &Message) -> Value {
 fn apply_responses_options(args: &mut Map<String, Value>, opts: &Option<ModelOptions>) {
     let Some(opts) = opts else { return };
 
-    if let Some(t) = opts.temperature {
-        args.insert("temperature".to_string(), f32_to_json(t));
-    }
-    if let Some(m) = opts.max_output_tokens {
-        args.insert("max_output_tokens".to_string(), json!(m));
-    }
-    if let Some(p) = opts.top_p {
-        args.insert("top_p".to_string(), f32_to_json(p));
+    let wire = opts.to_wire("responses");
+    if let Value::Object(map) = wire {
+        for (k, v) in map {
+            if !v.is_null() {
+                args.insert(k, fix_f32_value(v));
+            }
+        }
     }
 
     // additionalProperties — pass through without overwriting
@@ -573,18 +556,14 @@ fn responses_function_tool_to_wire(tool: &Tool) -> Value {
 
     // Collect bound parameter names to strip (§7.1.3)
     let bound_names: std::collections::HashSet<String> = tool
-        .as_bindings()
-        .unwrap_or_default()
+        .bindings
         .iter()
         .map(|b| b.name.clone())
         .collect();
 
-    if let Some(params) = parameters.as_array() {
-        use prompty::model::context::LoadContext;
-        let ctx = LoadContext::default();
-        let typed_params: Vec<Property> = params
+    {
+        let typed_params: Vec<&Property> = parameters
             .iter()
-            .map(|v| Property::load_from_value(v, &ctx))
             .filter(|p| !bound_names.contains(&p.name))
             .collect();
         let schema = parameters_to_json_schema(&typed_params);
@@ -610,7 +589,7 @@ fn output_schema_to_responses_wire(agent: &Prompty) -> Option<Value> {
     let mut properties = Map::new();
     let mut required = Vec::new();
 
-    for prop in &outputs {
+    for prop in outputs {
         properties.insert(prop.name.clone(), property_to_json_schema(prop));
         required.push(Value::String(prop.name.clone()));
     }
diff --git a/runtime/rust/prompty/src/lib.rs b/runtime/rust/prompty/src/lib.rs
index 4c34fdc5..5bd8fae9 100644
--- a/runtime/rust/prompty/src/lib.rs
+++ b/runtime/rust/prompty/src/lib.rs
@@ -41,6 +41,7 @@ pub mod guardrails;
 pub mod interfaces;
 pub mod loader;
 pub mod model;
+mod model_ext;
 pub mod parsers;
 pub mod pipeline;
 pub mod prelude;
diff --git a/runtime/rust/prompty/src/model/binding.rs b/runtime/rust/prompty/src/model/binding.rs
index a103de3e..f791ae73 100644
--- a/runtime/rust/prompty/src/model/binding.rs
+++ b/runtime/rust/prompty/src/model/binding.rs
@@ -1,5 +1,9 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
 /// Represents a binding between an input property and a tool parameter.
@@ -36,20 +40,11 @@ impl Binding {
         let value = ctx.process_input(value.clone());
         if let Some(s) = value.as_str() {
             let value = s.to_string();
-            let expansion = serde_json::json!({"input":value});
-            return Self::load_from_value(&expansion, ctx);
+            return Binding { input: value.into(), ..Default::default() };
         }
         Self {
-            name: value
-                .get("name")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-                .to_string(),
-            input: value
-                .get("input")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-                .to_string(),
+            name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            input: value.get("input").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
         }
     }
 
@@ -58,17 +53,12 @@ impl Binding {
     /// Calls `ctx.process_dict` after serialization.
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
+        // Write base fields
         if !self.name.is_empty() {
-            result.insert(
-                "name".to_string(),
-                serde_json::Value::String(self.name.clone()),
-            );
+            result.insert("name".to_string(), serde_json::Value::String(self.name.clone()));
         }
         if !self.input.is_empty() {
-            result.insert(
-                "input".to_string(),
-                serde_json::Value::String(self.input.clone()),
-            );
+            result.insert("input".to_string(), serde_json::Value::String(self.input.clone()));
         }
         ctx.process_dict(serde_json::Value::Object(result))
     }
diff --git a/runtime/rust/prompty/src/model/compaction_complete_payload.rs b/runtime/rust/prompty/src/model/compaction_complete_payload.rs
new file mode 100644
index 00000000..878f4e1d
--- /dev/null
+++ b/runtime/rust/prompty/src/model/compaction_complete_payload.rs
@@ -0,0 +1,71 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Payload for "compaction_complete" events — context compaction finished.
+#[derive(Debug, Clone, Default)]
+pub struct CompactionCompletePayload {
+    /// Number of messages removed during compaction
+    pub removed: i32,
+    /// Number of messages remaining after compaction
+    pub remaining: i32,
+}
+
+impl CompactionCompletePayload {
+    /// Create a new CompactionCompletePayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load CompactionCompletePayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load CompactionCompletePayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load CompactionCompletePayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            removed: value.get("removed").and_then(|v| v.as_i64()).unwrap_or(0) as i32,
+            remaining: value.get("remaining").and_then(|v| v.as_i64()).unwrap_or(0) as i32,
+        }
+    }
+
+    /// Serialize CompactionCompletePayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if self.removed != 0 {
+            result.insert("removed".to_string(), serde_json::Value::Number(serde_json::Number::from(self.removed)));
+        }
+        if self.remaining != 0 {
+            result.insert("remaining".to_string(), serde_json::Value::Number(serde_json::Number::from(self.remaining)));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize CompactionCompletePayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize CompactionCompletePayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/compaction_config.rs b/runtime/rust/prompty/src/model/compaction_config.rs
new file mode 100644
index 00000000..5faf5013
--- /dev/null
+++ b/runtime/rust/prompty/src/model/compaction_config.rs
@@ -0,0 +1,83 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Configuration for context window compaction. When the message history exceeds the context budget, the compaction strategy is applied to reduce the message list while preserving essential information.
+#[derive(Debug, Clone, Default)]
+pub struct CompactionConfig {
+    /// The compaction strategy identifier. Built-in strategies include 'summarize'. Can also be a path to a .prompty file used as the summarization prompt.
+    pub strategy: Option<String>,
+    /// Character budget for the compacted context. Overrides TurnOptions.contextBudget when set.
+    pub budget: Option<i32>,
+    /// Additional strategy-specific options
+    pub options: serde_json::Value,
+}
+
+impl CompactionConfig {
+    /// Create a new CompactionConfig with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load CompactionConfig from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load CompactionConfig from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load CompactionConfig from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            strategy: value.get("strategy").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            budget: value.get("budget").and_then(|v| v.as_i64()).map(|v| v as i32),
+            options: value.get("options").cloned().unwrap_or(serde_json::Value::Null),
+        }
+    }
+
+    /// Serialize CompactionConfig to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if let Some(ref val) = self.strategy {
+            result.insert("strategy".to_string(), serde_json::Value::String(val.clone()));
+        }
+        if let Some(val) = self.budget {
+            result.insert("budget".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
+        }
+        if !self.options.is_null() {
+            result.insert("options".to_string(), self.options.clone());
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize CompactionConfig to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize CompactionConfig to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+    /// Returns typed reference to the map if the field is an object.
+    /// Returns `None` if the field is null or not an object.
+    pub fn as_options_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
+        self.options.as_object()
+    }
+
+}
diff --git a/runtime/rust/prompty/src/model/compaction_failed_payload.rs b/runtime/rust/prompty/src/model/compaction_failed_payload.rs
new file mode 100644
index 00000000..5d6849ab
--- /dev/null
+++ b/runtime/rust/prompty/src/model/compaction_failed_payload.rs
@@ -0,0 +1,65 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Payload for "compaction_failed" events — compaction could not be completed.
+#[derive(Debug, Clone, Default)]
+pub struct CompactionFailedPayload {
+    /// Explanation of why compaction failed
+    pub message: String,
+}
+
+impl CompactionFailedPayload {
+    /// Create a new CompactionFailedPayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load CompactionFailedPayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load CompactionFailedPayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load CompactionFailedPayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            message: value.get("message").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+        }
+    }
+
+    /// Serialize CompactionFailedPayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.message.is_empty() {
+            result.insert("message".to_string(), serde_json::Value::String(self.message.clone()));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize CompactionFailedPayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize CompactionFailedPayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/connection.rs b/runtime/rust/prompty/src/model/connection.rs
index ea568ce6..f75ba1f0 100644
--- a/runtime/rust/prompty/src/model/connection.rs
+++ b/runtime/rust/prompty/src/model/connection.rs
@@ -1,7 +1,12 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
+
 /// Variant-specific data for [`Connection`], discriminated by `kind`.
 #[derive(Debug, Clone)]
 pub enum ConnectionKind {
@@ -31,15 +36,6 @@ pub enum ConnectionKind {
         /// The endpoint for authenticating with the AI service
         endpoint: String,
     },
-    /// `kind` = `"foundry"`
-    Foundry {
-        /// The Foundry project endpoint URL
-        endpoint: String,
-        /// The named connection within the Foundry project
-        name: Option<String>,
-        /// The connection type within the Foundry project (e.g., 'model', 'index', 'storage')
-        connection_type: Option<String>,
-    },
     /// `kind` = `"oauth"`
     OAuth {
         /// The endpoint URL for the service
@@ -53,6 +49,15 @@ pub enum ConnectionKind {
         /// OAuth scopes to request
         scopes: Option<Vec<String>>,
     },
+    /// `kind` = `"foundry"`
+    Foundry {
+        /// The Foundry project endpoint URL
+        endpoint: String,
+        /// The named connection within the Foundry project
+        name: Option<String>,
+        /// The connection type within the Foundry project (e.g., 'model', 'index', 'storage')
+        connection_type: Option<String>,
+    },
 }
 
 impl Default for ConnectionKind {
@@ -100,101 +105,38 @@ impl Connection {
         let kind_str = value.get("kind").and_then(|v| v.as_str()).unwrap_or("");
         let kind = match kind_str {
             "reference" => ConnectionKind::Reference {
-                name: value
-                    .get("name")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                target: value
-                    .get("target")
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.to_string()),
+                name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                target: value.get("target").and_then(|v| v.as_str()).map(|s| s.to_string()),
             },
             "remote" => ConnectionKind::Remote {
-                name: value
-                    .get("name")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                endpoint: value
-                    .get("endpoint")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
+                name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                endpoint: value.get("endpoint").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
             },
             "key" => ConnectionKind::ApiKey {
-                endpoint: value
-                    .get("endpoint")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                api_key: value
-                    .get("apiKey")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
+                endpoint: value.get("endpoint").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                api_key: value.get("apiKey").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
             },
             "anonymous" => ConnectionKind::Anonymous {
-                endpoint: value
-                    .get("endpoint")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-            },
-            "foundry" => ConnectionKind::Foundry {
-                endpoint: value
-                    .get("endpoint")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                name: value
-                    .get("name")
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.to_string()),
-                connection_type: value
-                    .get("connectionType")
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.to_string()),
+                endpoint: value.get("endpoint").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
             },
             "oauth" => ConnectionKind::OAuth {
-                endpoint: value
-                    .get("endpoint")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                client_id: value
-                    .get("clientId")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                client_secret: value
-                    .get("clientSecret")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                token_url: value
-                    .get("tokenUrl")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                scopes: value.get("scopes").and_then(|v| v.as_array()).map(|arr| {
-                    arr.iter()
-                        .filter_map(|v| v.as_str().map(|s| s.to_string()))
-                        .collect()
-                }),
+                endpoint: value.get("endpoint").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                client_id: value.get("clientId").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                client_secret: value.get("clientSecret").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                token_url: value.get("tokenUrl").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                scopes: value.get("scopes").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()),
+            },
+            "foundry" => ConnectionKind::Foundry {
+                endpoint: value.get("endpoint").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                name: value.get("name").and_then(|v| v.as_str()).map(|s| s.to_string()),
+                connection_type: value.get("connectionType").and_then(|v| v.as_str()).map(|s| s.to_string()),
             },
             _ => ConnectionKind::default(),
         };
         Self {
-            authentication_mode: value
-                .get("authenticationMode")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string()),
-            usage_description: value
-                .get("usageDescription")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string()),
-            kind,
+            authentication_mode: value.get("authenticationMode").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            usage_description: value.get("usageDescription").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            kind: kind,
         }
     }
 
@@ -205,8 +147,8 @@ impl Connection {
             ConnectionKind::Remote { .. } => "remote",
             ConnectionKind::ApiKey { .. } => "key",
             ConnectionKind::Anonymous { .. } => "anonymous",
-            ConnectionKind::Foundry { .. } => "foundry",
             ConnectionKind::OAuth { .. } => "oauth",
+            ConnectionKind::Foundry { .. } => "foundry",
         }
     }
 
@@ -216,26 +158,17 @@ impl Connection {
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
         // Write the discriminator
-        result.insert(
-            "kind".to_string(),
-            serde_json::Value::String(self.kind_str().to_string()),
-        );
+        result.insert("kind".to_string(), serde_json::Value::String(self.kind_str().to_string()));
         // Write base fields
         if let Some(ref val) = self.authentication_mode {
-            result.insert(
-                "authenticationMode".to_string(),
-                serde_json::Value::String(val.clone()),
-            );
+            result.insert("authenticationMode".to_string(), serde_json::Value::String(val.clone()));
         }
         if let Some(ref val) = self.usage_description {
-            result.insert(
-                "usageDescription".to_string(),
-                serde_json::Value::String(val.clone()),
-            );
+            result.insert("usageDescription".to_string(), serde_json::Value::String(val.clone()));
         }
         // Write variant-specific fields
         match &self.kind {
-            ConnectionKind::Reference { name, target, .. } => {
+            ConnectionKind::Reference { name, target,  .. } => {
                 if !name.is_empty() {
                     result.insert("name".to_string(), serde_json::Value::String(name.clone()));
                 }
@@ -243,100 +176,53 @@ impl Connection {
                     result.insert("target".to_string(), serde_json::Value::String(val.clone()));
                 }
             }
-            ConnectionKind::Remote { name, endpoint, .. } => {
+            ConnectionKind::Remote { name, endpoint,  .. } => {
                 if !name.is_empty() {
                     result.insert("name".to_string(), serde_json::Value::String(name.clone()));
                 }
                 if !endpoint.is_empty() {
-                    result.insert(
-                        "endpoint".to_string(),
-                        serde_json::Value::String(endpoint.clone()),
-                    );
+                    result.insert("endpoint".to_string(), serde_json::Value::String(endpoint.clone()));
                 }
             }
-            ConnectionKind::ApiKey {
-                endpoint, api_key, ..
-            } => {
+            ConnectionKind::ApiKey { endpoint, api_key,  .. } => {
                 if !endpoint.is_empty() {
-                    result.insert(
-                        "endpoint".to_string(),
-                        serde_json::Value::String(endpoint.clone()),
-                    );
+                    result.insert("endpoint".to_string(), serde_json::Value::String(endpoint.clone()));
                 }
                 if !api_key.is_empty() {
-                    result.insert(
-                        "apiKey".to_string(),
-                        serde_json::Value::String(api_key.clone()),
-                    );
+                    result.insert("apiKey".to_string(), serde_json::Value::String(api_key.clone()));
                 }
             }
-            ConnectionKind::Anonymous { endpoint, .. } => {
+            ConnectionKind::Anonymous { endpoint,  .. } => {
                 if !endpoint.is_empty() {
-                    result.insert(
-                        "endpoint".to_string(),
-                        serde_json::Value::String(endpoint.clone()),
-                    );
+                    result.insert("endpoint".to_string(), serde_json::Value::String(endpoint.clone()));
                 }
             }
-            ConnectionKind::Foundry {
-                endpoint,
-                name,
-                connection_type,
-                ..
-            } => {
+            ConnectionKind::OAuth { endpoint, client_id, client_secret, token_url, scopes,  .. } => {
                 if !endpoint.is_empty() {
-                    result.insert(
-                        "endpoint".to_string(),
-                        serde_json::Value::String(endpoint.clone()),
-                    );
-                }
-                if let Some(val) = name {
-                    result.insert("name".to_string(), serde_json::Value::String(val.clone()));
-                }
-                if let Some(val) = connection_type {
-                    result.insert(
-                        "connectionType".to_string(),
-                        serde_json::Value::String(val.clone()),
-                    );
-                }
-            }
-            ConnectionKind::OAuth {
-                endpoint,
-                client_id,
-                client_secret,
-                token_url,
-                scopes,
-                ..
-            } => {
-                if !endpoint.is_empty() {
-                    result.insert(
-                        "endpoint".to_string(),
-                        serde_json::Value::String(endpoint.clone()),
-                    );
+                    result.insert("endpoint".to_string(), serde_json::Value::String(endpoint.clone()));
                 }
                 if !client_id.is_empty() {
-                    result.insert(
-                        "clientId".to_string(),
-                        serde_json::Value::String(client_id.clone()),
-                    );
+                    result.insert("clientId".to_string(), serde_json::Value::String(client_id.clone()));
                 }
                 if !client_secret.is_empty() {
-                    result.insert(
-                        "clientSecret".to_string(),
-                        serde_json::Value::String(client_secret.clone()),
-                    );
+                    result.insert("clientSecret".to_string(), serde_json::Value::String(client_secret.clone()));
                 }
                 if !token_url.is_empty() {
-                    result.insert(
-                        "tokenUrl".to_string(),
-                        serde_json::Value::String(token_url.clone()),
-                    );
+                    result.insert("tokenUrl".to_string(), serde_json::Value::String(token_url.clone()));
                 }
                 if let Some(items) = scopes {
-                    result.insert(
-                        "scopes".to_string(),
-                        serde_json::to_value(items).unwrap_or(serde_json::Value::Null),
-                    );
+                    result.insert("scopes".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
+                }
+            }
+            ConnectionKind::Foundry { endpoint, name, connection_type,  .. } => {
+                if !endpoint.is_empty() {
+                    result.insert("endpoint".to_string(), serde_json::Value::String(endpoint.clone()));
+                }
+                if let Some(val) = name {
+                    result.insert("name".to_string(), serde_json::Value::String(val.clone()));
+                }
+                if let Some(val) = connection_type {
+                    result.insert("connectionType".to_string(), serde_json::Value::String(val.clone()));
                 }
             }
         }
@@ -353,3 +239,9 @@ impl Connection {
         serde_yaml::to_string(&self.to_value(ctx))
     }
 }
+
+
+
+
+
+
diff --git a/runtime/rust/prompty/src/model/content_part.rs b/runtime/rust/prompty/src/model/content_part.rs
new file mode 100644
index 00000000..da0977a5
--- /dev/null
+++ b/runtime/rust/prompty/src/model/content_part.rs
@@ -0,0 +1,174 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+
+/// Variant-specific data for [`ContentPart`], discriminated by `kind`.
+#[derive(Debug, Clone)]
+pub enum ContentPartKind {
+    /// `kind` = `"text"`
+    TextPart {
+        /// The text content
+        value: String,
+    },
+    /// `kind` = `"image"`
+    ImagePart {
+        /// URL or base64-encoded image data
+        source: String,
+        /// Detail level hint for the model (e.g., 'auto', 'low', 'high')
+        detail: Option<String>,
+        /// MIME type of the image (e.g., 'image/png')
+        media_type: Option<String>,
+    },
+    /// `kind` = `"file"`
+    FilePart {
+        /// URL or base64-encoded file data
+        source: String,
+        /// MIME type of the file (e.g., 'application/pdf')
+        media_type: Option<String>,
+    },
+    /// `kind` = `"audio"`
+    AudioPart {
+        /// URL or base64-encoded audio data
+        source: String,
+        /// MIME type of the audio (e.g., 'audio/wav')
+        media_type: Option<String>,
+    },
+}
+
+impl Default for ContentPartKind {
+    fn default() -> Self {
+        ContentPartKind::TextPart {
+            value: String::from(""),
+        }
+    }
+}
+/// A part of a message's content. Content parts are discriminated on the `kind` field and represent the different modalities that can appear in a message.
+#[derive(Debug, Clone, Default)]
+pub struct ContentPart {
+    /// Variant-specific data, discriminated by `kind`.
+    pub kind: ContentPartKind,
+}
+
+impl ContentPart {
+    /// Create a new ContentPart with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ContentPart from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ContentPart from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ContentPart from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        let kind_str = value.get("kind").and_then(|v| v.as_str()).unwrap_or("");
+        let kind = match kind_str {
+            "text" => ContentPartKind::TextPart {
+                value: value.get("value").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            },
+            "image" => ContentPartKind::ImagePart {
+                source: value.get("source").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                detail: value.get("detail").and_then(|v| v.as_str()).map(|s| s.to_string()),
+                media_type: value.get("mediaType").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            },
+            "file" => ContentPartKind::FilePart {
+                source: value.get("source").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                media_type: value.get("mediaType").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            },
+            "audio" => ContentPartKind::AudioPart {
+                source: value.get("source").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                media_type: value.get("mediaType").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            },
+            _ => ContentPartKind::default(),
+        };
+        Self {
+            kind: kind,
+        }
+    }
+
+    /// Returns the `kind` discriminator string for this instance.
+    pub fn kind_str(&self) -> &str {
+        match &self.kind {
+            ContentPartKind::TextPart { .. } => "text",
+            ContentPartKind::ImagePart { .. } => "image",
+            ContentPartKind::FilePart { .. } => "file",
+            ContentPartKind::AudioPart { .. } => "audio",
+        }
+    }
+
+    /// Serialize ContentPart to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write the discriminator
+        result.insert("kind".to_string(), serde_json::Value::String(self.kind_str().to_string()));
+        // Write base fields
+        // Write variant-specific fields
+        match &self.kind {
+            ContentPartKind::TextPart { value,  .. } => {
+                if !value.is_empty() {
+                    result.insert("value".to_string(), serde_json::Value::String(value.clone()));
+                }
+            }
+            ContentPartKind::ImagePart { source, detail, media_type,  .. } => {
+                if !source.is_empty() {
+                    result.insert("source".to_string(), serde_json::Value::String(source.clone()));
+                }
+                if let Some(val) = detail {
+                    result.insert("detail".to_string(), serde_json::Value::String(val.clone()));
+                }
+                if let Some(val) = media_type {
+                    result.insert("mediaType".to_string(), serde_json::Value::String(val.clone()));
+                }
+            }
+            ContentPartKind::FilePart { source, media_type,  .. } => {
+                if !source.is_empty() {
+                    result.insert("source".to_string(), serde_json::Value::String(source.clone()));
+                }
+                if let Some(val) = media_type {
+                    result.insert("mediaType".to_string(), serde_json::Value::String(val.clone()));
+                }
+            }
+            ContentPartKind::AudioPart { source, media_type,  .. } => {
+                if !source.is_empty() {
+                    result.insert("source".to_string(), serde_json::Value::String(source.clone()));
+                }
+                if let Some(val) = media_type {
+                    result.insert("mediaType".to_string(), serde_json::Value::String(val.clone()));
+                }
+            }
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ContentPart to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ContentPart to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
+
+
+
+
diff --git a/runtime/rust/prompty/src/model/context.rs b/runtime/rust/prompty/src/model/context.rs
index 0afa09c6..4103cda3 100644
--- a/runtime/rust/prompty/src/model/context.rs
+++ b/runtime/rust/prompty/src/model/context.rs
@@ -17,7 +17,6 @@ pub type PostSaveFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send
 ///
 /// Provides hooks for pre-processing input data before parsing and
 /// post-processing output data after instantiation.
-#[derive(Default)]
 pub struct LoadContext {
     /// Optional callback to transform input data before parsing.
     pub pre_process: Option<PreProcessFn>,
@@ -34,6 +33,15 @@ impl std::fmt::Debug for LoadContext {
     }
 }
 
+impl Default for LoadContext {
+    fn default() -> Self {
+        Self {
+            pre_process: None,
+            post_process: None,
+        }
+    }
+}
+
 impl LoadContext {
     /// Create a new empty LoadContext.
     pub fn new() -> Self {
@@ -152,11 +160,7 @@ impl SaveContext {
     }
 
     /// Convert a value to a JSON string.
-    pub fn to_json(
-        &self,
-        data: &serde_json::Value,
-        indent: bool,
-    ) -> Result<String, serde_json::Error> {
+    pub fn to_json(&self, data: &serde_json::Value, indent: bool) -> Result<String, serde_json::Error> {
         if indent {
             serde_json::to_string_pretty(data)
         } else {
diff --git a/runtime/rust/prompty/src/model/done_event_payload.rs b/runtime/rust/prompty/src/model/done_event_payload.rs
new file mode 100644
index 00000000..86a64a4e
--- /dev/null
+++ b/runtime/rust/prompty/src/model/done_event_payload.rs
@@ -0,0 +1,93 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+use super::message::Message;
+
+/// Payload for "done" events — the agent loop completed successfully.
+#[derive(Debug, Clone, Default)]
+pub struct DoneEventPayload {
+    /// The final text response from the LLM
+    pub response: String,
+    /// The final conversation state including all messages
+    pub messages: Vec<Message>,
+}
+
+impl DoneEventPayload {
+    /// Create a new DoneEventPayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load DoneEventPayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load DoneEventPayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load DoneEventPayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            response: value.get("response").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            messages: value.get("messages").map(|v| Self::load_messages(v, ctx)).unwrap_or_default(),
+        }
+    }
+
+    /// Serialize DoneEventPayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.response.is_empty() {
+            result.insert("response".to_string(), serde_json::Value::String(self.response.clone()));
+        }
+        if !self.messages.is_empty() {
+            result.insert("messages".to_string(), Self::save_messages(&self.messages, ctx));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize DoneEventPayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize DoneEventPayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+
+    /// Load a collection of Message from a JSON value.
+    /// Handles both array format `[{...}]`.
+    fn load_messages(data: &serde_json::Value, ctx: &LoadContext) -> Vec<Message> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| Message::load_from_value(v, ctx)).collect()
+            }
+
+            _ => Vec::new(),
+
+        }
+    }
+
+    /// Save a collection of Message to a JSON value.
+    fn save_messages(items: &[Message], ctx: &SaveContext) -> serde_json::Value {
+
+        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())
+
+    }
+}
diff --git a/runtime/rust/prompty/src/model/error_event_payload.rs b/runtime/rust/prompty/src/model/error_event_payload.rs
new file mode 100644
index 00000000..0749c533
--- /dev/null
+++ b/runtime/rust/prompty/src/model/error_event_payload.rs
@@ -0,0 +1,65 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Payload for "error" events — an error occurred during the loop.
+#[derive(Debug, Clone, Default)]
+pub struct ErrorEventPayload {
+    /// Human-readable error description
+    pub message: String,
+}
+
+impl ErrorEventPayload {
+    /// Create a new ErrorEventPayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ErrorEventPayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ErrorEventPayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ErrorEventPayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            message: value.get("message").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+        }
+    }
+
+    /// Serialize ErrorEventPayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.message.is_empty() {
+            result.insert("message".to_string(), serde_json::Value::String(self.message.clone()));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ErrorEventPayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ErrorEventPayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/executor.rs b/runtime/rust/prompty/src/model/executor.rs
new file mode 100644
index 00000000..597d0dc4
--- /dev/null
+++ b/runtime/rust/prompty/src/model/executor.rs
@@ -0,0 +1,25 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+
+use super::message::Message;
+
+use super::prompty::Prompty;
+
+use super::tool_call::ToolCall;
+
+/// Calls an LLM provider with messages and returns the raw provider response.
+#[async_trait::async_trait]
+pub trait Executor: Send + Sync {
+    /// Call an LLM provider with messages and return the raw response
+    async fn execute(&self, agent: &Prompty, messages: &Vec<Message>) -> Result<serde_json::Value, Box<dyn std::error::Error + Send + Sync>>;
+    /// Call an LLM provider and return a streaming response. Returns a language-specific async iterable/stream of raw chunks. Not all providers support streaming; the default implementation should signal lack of support.
+    async fn execute_stream(&self, agent: &Prompty, messages: &Vec<Message>) -> Result<serde_json::Value, Box<dyn std::error::Error + Send + Sync>> {
+        Err("not supported".into())
+    }
+    /// Format tool call results into messages for the next iteration
+    fn format_tool_messages(&self, raw_response: &serde_json::Value, tool_calls: &Vec<ToolCall>, tool_results: &Vec<String>, text_content: &Option<String>) -> Vec<Message>;
+}
diff --git a/runtime/rust/prompty/src/model/format_config.rs b/runtime/rust/prompty/src/model/format_config.rs
index 1c5e2c16..237cc4ff 100644
--- a/runtime/rust/prompty/src/model/format_config.rs
+++ b/runtime/rust/prompty/src/model/format_config.rs
@@ -1,5 +1,9 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
 /// Template format definition
@@ -38,20 +42,12 @@ impl FormatConfig {
         let value = ctx.process_input(value.clone());
         if let Some(s) = value.as_str() {
             let value = s.to_string();
-            let expansion = serde_json::json!({"kind":value});
-            return Self::load_from_value(&expansion, ctx);
+            return FormatConfig { kind: value.into(), ..Default::default() };
         }
         Self {
-            kind: value
-                .get("kind")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-                .to_string(),
+            kind: value.get("kind").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
             strict: value.get("strict").and_then(|v| v.as_bool()),
-            options: value
-                .get("options")
-                .cloned()
-                .unwrap_or(serde_json::Value::Null),
+            options: value.get("options").cloned().unwrap_or(serde_json::Value::Null),
         }
     }
 
@@ -60,11 +56,9 @@ impl FormatConfig {
     /// Calls `ctx.process_dict` after serialization.
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
+        // Write base fields
         if !self.kind.is_empty() {
-            result.insert(
-                "kind".to_string(),
-                serde_json::Value::String(self.kind.clone()),
-            );
+            result.insert("kind".to_string(), serde_json::Value::String(self.kind.clone()));
         }
         if let Some(val) = self.strict {
             result.insert("strict".to_string(), serde_json::Value::Bool(val));
@@ -89,4 +83,5 @@ impl FormatConfig {
     pub fn as_options_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
         self.options.as_object()
     }
+
 }
diff --git a/runtime/rust/prompty/src/model/guardrail_result.rs b/runtime/rust/prompty/src/model/guardrail_result.rs
new file mode 100644
index 00000000..cefc2ce6
--- /dev/null
+++ b/runtime/rust/prompty/src/model/guardrail_result.rs
@@ -0,0 +1,87 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// The result of a guardrail evaluation. Guardrails are safety checks that run at specific phases of the agent loop and can allow, deny, or rewrite content.
+#[derive(Debug, Clone, Default)]
+pub struct GuardrailResult {
+    /// Whether the content passed the guardrail check
+    pub allowed: bool,
+    /// Explanation of why the content was allowed or denied
+    pub reason: Option<String>,
+    /// Optional rewritten content to replace the original
+    pub rewrite: Option<serde_json::Value>,
+}
+
+impl GuardrailResult {
+    /// Create a new GuardrailResult with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load GuardrailResult from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load GuardrailResult from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load GuardrailResult from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            allowed: value.get("allowed").and_then(|v| v.as_bool()).unwrap_or(false),
+            reason: value.get("reason").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            rewrite: value.get("rewrite").cloned(),
+        }
+    }
+
+    /// Serialize GuardrailResult to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        result.insert("allowed".to_string(), serde_json::Value::Bool(self.allowed));
+        if let Some(ref val) = self.reason {
+            result.insert("reason".to_string(), serde_json::Value::String(val.clone()));
+        }
+        if let Some(ref val) = self.rewrite {
+            result.insert("rewrite".to_string(), val.clone());
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize GuardrailResult to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize GuardrailResult to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+    /// Create a GuardrailResult with preset field values.
+    pub fn rewrite(rewrite: impl Into<serde_json::Value>) -> Self {
+        GuardrailResult { allowed: true, rewrite: Some(rewrite.into()), ..Default::default() }
+    }
+    /// Create a GuardrailResult with preset field values.
+    pub fn deny(reason: impl Into<String>) -> Self {
+        GuardrailResult { allowed: false, reason: Some(reason.into()), ..Default::default() }
+    }
+    /// Create a GuardrailResult with preset field values.
+    pub fn allow() -> Self {
+        GuardrailResult { allowed: true, ..Default::default() }
+    }
+}
diff --git a/runtime/rust/prompty/src/model/mcp_approval_mode.rs b/runtime/rust/prompty/src/model/mcp_approval_mode.rs
index e406e8c9..4138b1db 100644
--- a/runtime/rust/prompty/src/model/mcp_approval_mode.rs
+++ b/runtime/rust/prompty/src/model/mcp_approval_mode.rs
@@ -1,5 +1,9 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
 /// The approval mode for MCP server tools. When kind is "specify", use alwaysRequireApprovalTools and neverRequireApprovalTools to control per-tool approval. For "always" and "never", those fields are ignored.
@@ -38,31 +42,12 @@ impl McpApprovalMode {
         let value = ctx.process_input(value.clone());
         if let Some(s) = value.as_str() {
             let value = s.to_string();
-            let expansion = serde_json::json!({"kind":value});
-            return Self::load_from_value(&expansion, ctx);
+            return McpApprovalMode { kind: value.into(), ..Default::default() };
         }
         Self {
-            kind: value
-                .get("kind")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-                .to_string(),
-            always_require_approval_tools: value
-                .get("alwaysRequireApprovalTools")
-                .and_then(|v| v.as_array())
-                .map(|arr| {
-                    arr.iter()
-                        .filter_map(|v| v.as_str().map(|s| s.to_string()))
-                        .collect()
-                }),
-            never_require_approval_tools: value
-                .get("neverRequireApprovalTools")
-                .and_then(|v| v.as_array())
-                .map(|arr| {
-                    arr.iter()
-                        .filter_map(|v| v.as_str().map(|s| s.to_string()))
-                        .collect()
-                }),
+            kind: value.get("kind").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            always_require_approval_tools: value.get("alwaysRequireApprovalTools").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()),
+            never_require_approval_tools: value.get("neverRequireApprovalTools").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()),
         }
     }
 
@@ -71,23 +56,15 @@ impl McpApprovalMode {
     /// Calls `ctx.process_dict` after serialization.
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
+        // Write base fields
         if !self.kind.is_empty() {
-            result.insert(
-                "kind".to_string(),
-                serde_json::Value::String(self.kind.clone()),
-            );
+            result.insert("kind".to_string(), serde_json::Value::String(self.kind.clone()));
         }
         if let Some(ref items) = self.always_require_approval_tools {
-            result.insert(
-                "alwaysRequireApprovalTools".to_string(),
-                serde_json::to_value(items).unwrap_or(serde_json::Value::Null),
-            );
+            result.insert("alwaysRequireApprovalTools".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
         }
         if let Some(ref items) = self.never_require_approval_tools {
-            result.insert(
-                "neverRequireApprovalTools".to_string(),
-                serde_json::to_value(items).unwrap_or(serde_json::Value::Null),
-            );
+            result.insert("neverRequireApprovalTools".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
         }
         ctx.process_dict(serde_json::Value::Object(result))
     }
diff --git a/runtime/rust/prompty/src/model/message.rs b/runtime/rust/prompty/src/model/message.rs
new file mode 100644
index 00000000..8b12b085
--- /dev/null
+++ b/runtime/rust/prompty/src/model/message.rs
@@ -0,0 +1,124 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+use super::content_part::{ContentPart, ContentPartKind};
+
+/// A message in a conversation. Messages have a role and a list of content parts representing the different modalities of the message content.
+#[derive(Debug, Clone, Default)]
+pub struct Message {
+    /// The role of the message sender
+    pub role: String,
+    /// The content parts of the message
+    pub parts: Vec<ContentPart>,
+    /// Optional metadata associated with the message
+    pub metadata: serde_json::Value,
+}
+
+impl Message {
+    /// Create a new Message with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load Message from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load Message from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load Message from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            role: value.get("role").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            parts: value.get("parts").map(|v| Self::load_parts(v, ctx)).unwrap_or_default(),
+            metadata: value.get("metadata").cloned().unwrap_or(serde_json::Value::Null),
+        }
+    }
+
+    /// Serialize Message to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.role.is_empty() {
+            result.insert("role".to_string(), serde_json::Value::String(self.role.clone()));
+        }
+        if !self.parts.is_empty() {
+            result.insert("parts".to_string(), Self::save_parts(&self.parts, ctx));
+        }
+        if !self.metadata.is_null() {
+            result.insert("metadata".to_string(), self.metadata.clone());
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize Message to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize Message to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+    /// Returns typed reference to the map if the field is an object.
+    /// Returns `None` if the field is null or not an object.
+    pub fn as_metadata_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
+        self.metadata.as_object()
+    }
+
+
+    /// Load a collection of ContentPart from a JSON value.
+    /// Handles both array format `[{...}]`.
+    fn load_parts(data: &serde_json::Value, ctx: &LoadContext) -> Vec<ContentPart> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| ContentPart::load_from_value(v, ctx)).collect()
+            }
+
+            _ => Vec::new(),
+
+        }
+    }
+
+    /// Save a collection of ContentPart to a JSON value.
+    fn save_parts(items: &[ContentPart], ctx: &SaveContext) -> serde_json::Value {
+
+        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())
+
+    }
+    /// Create a Message with preset field values.
+    pub fn assistant(text: impl Into<String>) -> Self {
+        Message { role: "assistant".to_string(), parts: vec![ContentPart { kind: ContentPartKind::TextPart { value: text.into() }, ..Default::default() }], ..Default::default() }
+    }
+    /// Create a Message with preset field values.
+    pub fn system(text: impl Into<String>) -> Self {
+        Message { role: "system".to_string(), parts: vec![ContentPart { kind: ContentPartKind::TextPart { value: text.into() }, ..Default::default() }], ..Default::default() }
+    }
+    /// Create a Message with preset field values.
+    pub fn user(text: impl Into<String>) -> Self {
+        Message { role: "user".to_string(), parts: vec![ContentPart { kind: ContentPartKind::TextPart { value: text.into() }, ..Default::default() }], ..Default::default() }
+    }
+}
+/// Helpers for [`Message`]. Implement in a separate file.
+pub trait MessageHelpers {
+    /// Return plain string if all parts are text, else a list of content part dicts for wire serialization
+    fn to_text_content(&self) -> serde_json::Value;
+    /// Concatenate all TextPart values joined by newline
+    fn text(&self) -> String;
+}
diff --git a/runtime/rust/prompty/src/model/messages_updated_payload.rs b/runtime/rust/prompty/src/model/messages_updated_payload.rs
new file mode 100644
index 00000000..3d926370
--- /dev/null
+++ b/runtime/rust/prompty/src/model/messages_updated_payload.rs
@@ -0,0 +1,87 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+use super::message::Message;
+
+/// Payload for "messages_updated" events — the conversation state has changed.
+#[derive(Debug, Clone, Default)]
+pub struct MessagesUpdatedPayload {
+    /// The current full message list after the update
+    pub messages: Vec<Message>,
+}
+
+impl MessagesUpdatedPayload {
+    /// Create a new MessagesUpdatedPayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load MessagesUpdatedPayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load MessagesUpdatedPayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load MessagesUpdatedPayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            messages: value.get("messages").map(|v| Self::load_messages(v, ctx)).unwrap_or_default(),
+        }
+    }
+
+    /// Serialize MessagesUpdatedPayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.messages.is_empty() {
+            result.insert("messages".to_string(), Self::save_messages(&self.messages, ctx));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize MessagesUpdatedPayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize MessagesUpdatedPayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+
+    /// Load a collection of Message from a JSON value.
+    /// Handles both array format `[{...}]`.
+    fn load_messages(data: &serde_json::Value, ctx: &LoadContext) -> Vec<Message> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| Message::load_from_value(v, ctx)).collect()
+            }
+
+            _ => Vec::new(),
+
+        }
+    }
+
+    /// Save a collection of Message to a JSON value.
+    fn save_messages(items: &[Message], ctx: &SaveContext) -> serde_json::Value {
+
+        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())
+
+    }
+}
diff --git a/runtime/rust/prompty/src/model/mod.rs b/runtime/rust/prompty/src/model/mod.rs
index ba9059be..4e30c0dc 100644
--- a/runtime/rust/prompty/src/model/mod.rs
+++ b/runtime/rust/prompty/src/model/mod.rs
@@ -12,7 +12,6 @@ pub use connection::*;
 pub mod model_options;
 pub use model_options::*;
 
-#[allow(clippy::module_inception)]
 pub mod model;
 pub use model::*;
 
@@ -36,3 +35,84 @@ pub use template::*;
 
 pub mod prompty;
 pub use prompty::*;
+
+pub mod content_part;
+pub use content_part::*;
+
+pub mod message;
+pub use message::*;
+
+pub mod tool_context;
+pub use tool_context::*;
+
+pub mod tool_result;
+pub use tool_result::*;
+
+pub mod tool_dispatch_result;
+pub use tool_dispatch_result::*;
+
+pub mod tool_call;
+pub use tool_call::*;
+
+pub mod guardrail_result;
+pub use guardrail_result::*;
+
+pub mod thread_marker;
+pub use thread_marker::*;
+
+pub mod token_usage;
+pub use token_usage::*;
+
+pub mod model_info;
+pub use model_info::*;
+
+pub mod compaction_config;
+pub use compaction_config::*;
+
+pub mod turn_options;
+pub use turn_options::*;
+
+pub mod renderer;
+pub use renderer::*;
+
+pub mod parser;
+pub use parser::*;
+
+pub mod executor;
+pub use executor::*;
+
+pub mod processor;
+pub use processor::*;
+
+pub mod token_event_payload;
+pub use token_event_payload::*;
+
+pub mod thinking_event_payload;
+pub use thinking_event_payload::*;
+
+pub mod tool_call_start_payload;
+pub use tool_call_start_payload::*;
+
+pub mod tool_result_payload;
+pub use tool_result_payload::*;
+
+pub mod status_event_payload;
+pub use status_event_payload::*;
+
+pub mod messages_updated_payload;
+pub use messages_updated_payload::*;
+
+pub mod done_event_payload;
+pub use done_event_payload::*;
+
+pub mod error_event_payload;
+pub use error_event_payload::*;
+
+pub mod compaction_complete_payload;
+pub use compaction_complete_payload::*;
+
+pub mod compaction_failed_payload;
+pub use compaction_failed_payload::*;
+
+pub mod stream_chunk;
+pub use stream_chunk::*;
diff --git a/runtime/rust/prompty/src/model/model.rs b/runtime/rust/prompty/src/model/model.rs
index 11534bb5..0382c91f 100644
--- a/runtime/rust/prompty/src/model/model.rs
+++ b/runtime/rust/prompty/src/model/model.rs
@@ -1,7 +1,13 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
+use super::connection::Connection;
+
 use super::model_options::ModelOptions;
 
 /// Model for defining the structure and behavior of AI agents. This model includes properties for specifying the model's provider, connection details, and various options. It allows for flexible configuration of AI models to suit different use cases and requirements.
@@ -44,31 +50,14 @@ impl Model {
         let value = ctx.process_input(value.clone());
         if let Some(s) = value.as_str() {
             let value = s.to_string();
-            let expansion = serde_json::json!({"id":value});
-            return Self::load_from_value(&expansion, ctx);
+            return Model { id: value.into(), ..Default::default() };
         }
         Self {
-            id: value
-                .get("id")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-                .to_string(),
-            provider: value
-                .get("provider")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string()),
-            api_type: value
-                .get("apiType")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string()),
-            connection: value
-                .get("connection")
-                .cloned()
-                .unwrap_or(serde_json::Value::Null),
-            options: value
-                .get("options")
-                .filter(|v| v.is_object() || v.is_array() || v.is_string())
-                .map(|v| ModelOptions::load_from_value(v, ctx)),
+            id: value.get("id").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            provider: value.get("provider").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            api_type: value.get("apiType").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            connection: value.get("connection").cloned().unwrap_or(serde_json::Value::Null),
+            options: value.get("options").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ModelOptions::load_from_value(v, ctx)),
         }
     }
 
@@ -77,20 +66,15 @@ impl Model {
     /// Calls `ctx.process_dict` after serialization.
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
+        // Write base fields
         if !self.id.is_empty() {
             result.insert("id".to_string(), serde_json::Value::String(self.id.clone()));
         }
         if let Some(ref val) = self.provider {
-            result.insert(
-                "provider".to_string(),
-                serde_json::Value::String(val.clone()),
-            );
+            result.insert("provider".to_string(), serde_json::Value::String(val.clone()));
         }
         if let Some(ref val) = self.api_type {
-            result.insert(
-                "apiType".to_string(),
-                serde_json::Value::String(val.clone()),
-            );
+            result.insert("apiType".to_string(), serde_json::Value::String(val.clone()));
         }
         if !self.connection.is_null() {
             result.insert("connection".to_string(), self.connection.clone());
diff --git a/runtime/rust/prompty/src/model/model_info.rs b/runtime/rust/prompty/src/model/model_info.rs
new file mode 100644
index 00000000..49e90b92
--- /dev/null
+++ b/runtime/rust/prompty/src/model/model_info.rs
@@ -0,0 +1,107 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Information about a model available from a provider. Used by provider-level model discovery to report which models are available and their capabilities. Not all providers return all fields — implementations SHOULD populate as many fields as the provider's API supports and MAY enrich sparse results from a built-in lookup table of known models.
+#[derive(Debug, Clone, Default)]
+pub struct ModelInfo {
+    /// The model identifier (e.g., 'gpt-4o', 'claude-3-opus')
+    pub id: String,
+    /// Human-readable display name
+    pub display_name: Option<String>,
+    /// The organization or entity that owns the model
+    pub owned_by: Option<String>,
+    /// Maximum context window size in tokens
+    pub context_window: Option<i32>,
+    /// Input modalities the model accepts (e.g., 'text', 'image', 'audio')
+    pub input_modalities: Option<Vec<String>>,
+    /// Output modalities the model can produce (e.g., 'text', 'audio')
+    pub output_modalities: Option<Vec<String>>,
+    /// Additional provider-specific properties
+    pub additional_properties: serde_json::Value,
+}
+
+impl ModelInfo {
+    /// Create a new ModelInfo with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ModelInfo from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ModelInfo from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ModelInfo from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            id: value.get("id").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            display_name: value.get("displayName").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            owned_by: value.get("ownedBy").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            context_window: value.get("contextWindow").and_then(|v| v.as_i64()).map(|v| v as i32),
+            input_modalities: value.get("inputModalities").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()),
+            output_modalities: value.get("outputModalities").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()),
+            additional_properties: value.get("additionalProperties").cloned().unwrap_or(serde_json::Value::Null),
+        }
+    }
+
+    /// Serialize ModelInfo to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.id.is_empty() {
+            result.insert("id".to_string(), serde_json::Value::String(self.id.clone()));
+        }
+        if let Some(ref val) = self.display_name {
+            result.insert("displayName".to_string(), serde_json::Value::String(val.clone()));
+        }
+        if let Some(ref val) = self.owned_by {
+            result.insert("ownedBy".to_string(), serde_json::Value::String(val.clone()));
+        }
+        if let Some(val) = self.context_window {
+            result.insert("contextWindow".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
+        }
+        if let Some(ref items) = self.input_modalities {
+            result.insert("inputModalities".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
+        }
+        if let Some(ref items) = self.output_modalities {
+            result.insert("outputModalities".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
+        }
+        if !self.additional_properties.is_null() {
+            result.insert("additionalProperties".to_string(), self.additional_properties.clone());
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ModelInfo to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ModelInfo to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+    /// Returns typed reference to the map if the field is an object.
+    /// Returns `None` if the field is null or not an object.
+    pub fn as_additional_properties_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
+        self.additional_properties.as_object()
+    }
+
+}
diff --git a/runtime/rust/prompty/src/model/model_options.rs b/runtime/rust/prompty/src/model/model_options.rs
index ae7b44e1..b2ba6ff8 100644
--- a/runtime/rust/prompty/src/model/model_options.rs
+++ b/runtime/rust/prompty/src/model/model_options.rs
@@ -1,9 +1,14 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
 /// Options for configuring the behavior of the AI model.
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct ModelOptions {
     /// The frequency penalty to apply to the model's output
     pub frequency_penalty: Option<f32>,
@@ -51,40 +56,16 @@ impl ModelOptions {
     pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
         let value = ctx.process_input(value.clone());
         Self {
-            frequency_penalty: value
-                .get("frequencyPenalty")
-                .and_then(|v| v.as_f64())
-                .map(|n| n as f32),
-            max_output_tokens: value
-                .get("maxOutputTokens")
-                .and_then(|v| v.as_i64())
-                .map(|n| n as i32),
-            presence_penalty: value
-                .get("presencePenalty")
-                .and_then(|v| v.as_f64())
-                .map(|n| n as f32),
-            seed: value.get("seed").and_then(|v| v.as_i64()).map(|n| n as i32),
-            temperature: value
-                .get("temperature")
-                .and_then(|v| v.as_f64())
-                .map(|n| n as f32),
-            top_k: value.get("topK").and_then(|v| v.as_i64()).map(|n| n as i32),
-            top_p: value.get("topP").and_then(|v| v.as_f64()).map(|n| n as f32),
-            stop_sequences: value
-                .get("stopSequences")
-                .and_then(|v| v.as_array())
-                .map(|arr| {
-                    arr.iter()
-                        .filter_map(|v| v.as_str().map(|s| s.to_string()))
-                        .collect()
-                }),
-            allow_multiple_tool_calls: value
-                .get("allowMultipleToolCalls")
-                .and_then(|v| v.as_bool()),
-            additional_properties: value
-                .get("additionalProperties")
-                .cloned()
-                .unwrap_or(serde_json::Value::Null),
+            frequency_penalty: value.get("frequencyPenalty").and_then(|v| v.as_f64()).map(|v| v as f32),
+            max_output_tokens: value.get("maxOutputTokens").and_then(|v| v.as_i64()).map(|v| v as i32),
+            presence_penalty: value.get("presencePenalty").and_then(|v| v.as_f64()).map(|v| v as f32),
+            seed: value.get("seed").and_then(|v| v.as_i64()).map(|v| v as i32),
+            temperature: value.get("temperature").and_then(|v| v.as_f64()).map(|v| v as f32),
+            top_k: value.get("topK").and_then(|v| v.as_i64()).map(|v| v as i32),
+            top_p: value.get("topP").and_then(|v| v.as_f64()).map(|v| v as f32),
+            stop_sequences: value.get("stopSequences").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()),
+            allow_multiple_tool_calls: value.get("allowMultipleToolCalls").and_then(|v| v.as_bool()),
+            additional_properties: value.get("additionalProperties").cloned().unwrap_or(serde_json::Value::Null),
         }
     }
 
@@ -93,65 +74,36 @@ impl ModelOptions {
     /// Calls `ctx.process_dict` after serialization.
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
-        if let Some(ref val) = self.frequency_penalty {
-            result.insert(
-                "frequencyPenalty".to_string(),
-                serde_json::to_value(val).unwrap_or(serde_json::Value::Null),
-            );
+        // Write base fields
+        if let Some(val) = self.frequency_penalty {
+            result.insert("frequencyPenalty".to_string(), serde_json::Number::from_f64(val as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));
         }
-        if let Some(ref val) = self.max_output_tokens {
-            result.insert(
-                "maxOutputTokens".to_string(),
-                serde_json::to_value(val).unwrap_or(serde_json::Value::Null),
-            );
+        if let Some(val) = self.max_output_tokens {
+            result.insert("maxOutputTokens".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
         }
-        if let Some(ref val) = self.presence_penalty {
-            result.insert(
-                "presencePenalty".to_string(),
-                serde_json::to_value(val).unwrap_or(serde_json::Value::Null),
-            );
+        if let Some(val) = self.presence_penalty {
+            result.insert("presencePenalty".to_string(), serde_json::Number::from_f64(val as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));
         }
-        if let Some(ref val) = self.seed {
-            result.insert(
-                "seed".to_string(),
-                serde_json::to_value(val).unwrap_or(serde_json::Value::Null),
-            );
+        if let Some(val) = self.seed {
+            result.insert("seed".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
         }
-        if let Some(ref val) = self.temperature {
-            result.insert(
-                "temperature".to_string(),
-                serde_json::to_value(val).unwrap_or(serde_json::Value::Null),
-            );
+        if let Some(val) = self.temperature {
+            result.insert("temperature".to_string(), serde_json::Number::from_f64(val as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));
         }
-        if let Some(ref val) = self.top_k {
-            result.insert(
-                "topK".to_string(),
-                serde_json::to_value(val).unwrap_or(serde_json::Value::Null),
-            );
+        if let Some(val) = self.top_k {
+            result.insert("topK".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
         }
-        if let Some(ref val) = self.top_p {
-            result.insert(
-                "topP".to_string(),
-                serde_json::to_value(val).unwrap_or(serde_json::Value::Null),
-            );
+        if let Some(val) = self.top_p {
+            result.insert("topP".to_string(), serde_json::Number::from_f64(val as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));
         }
         if let Some(ref items) = self.stop_sequences {
-            result.insert(
-                "stopSequences".to_string(),
-                serde_json::to_value(items).unwrap_or(serde_json::Value::Null),
-            );
+            result.insert("stopSequences".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
         }
         if let Some(val) = self.allow_multiple_tool_calls {
-            result.insert(
-                "allowMultipleToolCalls".to_string(),
-                serde_json::Value::Bool(val),
-            );
+            result.insert("allowMultipleToolCalls".to_string(), serde_json::Value::Bool(val));
         }
         if !self.additional_properties.is_null() {
-            result.insert(
-                "additionalProperties".to_string(),
-                self.additional_properties.clone(),
-            );
+            result.insert("additionalProperties".to_string(), self.additional_properties.clone());
         }
         ctx.process_dict(serde_json::Value::Object(result))
     }
@@ -165,11 +117,37 @@ impl ModelOptions {
     pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
         serde_yaml::to_string(&self.to_value(ctx))
     }
+
+    /// Convert to provider-specific wire format.
+    pub fn to_wire(&self, provider: &str) -> serde_json::Value {
+        let data = serde_json::to_value(self).unwrap_or_default();
+        let mut result = serde_json::Map::new();
+        let wire_map: std::collections::HashMap<&str, std::collections::HashMap<&str, &str>> = std::collections::HashMap::from([
+            ("frequencyPenalty", std::collections::HashMap::from([("openai", "frequency_penalty")])),
+            ("maxOutputTokens", std::collections::HashMap::from([("openai", "max_completion_tokens"), ("responses", "max_output_tokens"), ("anthropic", "max_tokens")])),
+            ("presencePenalty", std::collections::HashMap::from([("openai", "presence_penalty")])),
+            ("seed", std::collections::HashMap::from([("openai", "seed")])),
+            ("temperature", std::collections::HashMap::from([("openai", "temperature"), ("responses", "temperature"), ("anthropic", "temperature")])),
+            ("topK", std::collections::HashMap::from([("openai", "top_k"), ("anthropic", "top_k")])),
+            ("topP", std::collections::HashMap::from([("openai", "top_p"), ("responses", "top_p"), ("anthropic", "top_p")])),
+            ("stopSequences", std::collections::HashMap::from([("openai", "stop"), ("anthropic", "stop_sequences")])),
+            ("allowMultipleToolCalls", std::collections::HashMap::from([("openai", "parallel_tool_calls")])),
+        ]);
+        if let serde_json::Value::Object(map) = data {
+            for (key, value) in map {
+                if let Some(mapping) = wire_map.get(key.as_str()) {
+                    if let Some(wire_name) = mapping.get(provider) {
+                        result.insert(wire_name.to_string(), value);
+                    }
+                }
+            }
+        }
+        serde_json::Value::Object(result)
+    }
     /// Returns typed reference to the map if the field is an object.
     /// Returns `None` if the field is null or not an object.
-    pub fn as_additional_properties_dict(
-        &self,
-    ) -> Option<&serde_json::Map<String, serde_json::Value>> {
+    pub fn as_additional_properties_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
         self.additional_properties.as_object()
     }
+
 }
diff --git a/runtime/rust/prompty/src/model/parser.rs b/runtime/rust/prompty/src/model/parser.rs
new file mode 100644
index 00000000..e4dd67f7
--- /dev/null
+++ b/runtime/rust/prompty/src/model/parser.rs
@@ -0,0 +1,21 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+
+use super::message::Message;
+
+use super::prompty::Prompty;
+
+/// Parses rendered prompt text into an array of structured messages with role markers.
+#[async_trait::async_trait]
+pub trait Parser: Send + Sync {
+    /// Pre-process a template before rendering, returning modified template and context
+    fn pre_render(&self, template: &String) -> Option<serde_json::Value> {
+        None
+    }
+    /// Parse rendered text into a structured message array
+    async fn parse(&self, agent: &Prompty, rendered: &String, context: &Option<serde_json::Value>) -> Result<Vec<Message>, Box<dyn std::error::Error + Send + Sync>>;
+}
diff --git a/runtime/rust/prompty/src/model/parser_config.rs b/runtime/rust/prompty/src/model/parser_config.rs
index 6a864640..b234a590 100644
--- a/runtime/rust/prompty/src/model/parser_config.rs
+++ b/runtime/rust/prompty/src/model/parser_config.rs
@@ -1,5 +1,9 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
 /// Template parser definition
@@ -36,19 +40,11 @@ impl ParserConfig {
         let value = ctx.process_input(value.clone());
         if let Some(s) = value.as_str() {
             let value = s.to_string();
-            let expansion = serde_json::json!({"kind":value});
-            return Self::load_from_value(&expansion, ctx);
+            return ParserConfig { kind: value.into(), ..Default::default() };
         }
         Self {
-            kind: value
-                .get("kind")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-                .to_string(),
-            options: value
-                .get("options")
-                .cloned()
-                .unwrap_or(serde_json::Value::Null),
+            kind: value.get("kind").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            options: value.get("options").cloned().unwrap_or(serde_json::Value::Null),
         }
     }
 
@@ -57,11 +53,9 @@ impl ParserConfig {
     /// Calls `ctx.process_dict` after serialization.
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
+        // Write base fields
         if !self.kind.is_empty() {
-            result.insert(
-                "kind".to_string(),
-                serde_json::Value::String(self.kind.clone()),
-            );
+            result.insert("kind".to_string(), serde_json::Value::String(self.kind.clone()));
         }
         if !self.options.is_null() {
             result.insert("options".to_string(), self.options.clone());
@@ -83,4 +77,5 @@ impl ParserConfig {
     pub fn as_options_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
         self.options.as_object()
     }
+
 }
diff --git a/runtime/rust/prompty/src/model/processor.rs b/runtime/rust/prompty/src/model/processor.rs
new file mode 100644
index 00000000..9e72006c
--- /dev/null
+++ b/runtime/rust/prompty/src/model/processor.rs
@@ -0,0 +1,19 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+
+use super::prompty::Prompty;
+
+/// Extracts a clean, typed result from a raw LLM provider response.
+#[async_trait::async_trait]
+pub trait Processor: Send + Sync {
+    /// Extract a clean result from a raw LLM response
+    async fn process(&self, agent: &Prompty, response: &serde_json::Value) -> Result<serde_json::Value, Box<dyn std::error::Error + Send + Sync>>;
+    /// Process a streaming response into a stream of StreamChunk items. Takes raw chunks from the executor and yields processed text, thinking, tool, or error chunks. Not all providers support streaming; the default implementation should signal lack of support.
+    async fn process_stream(&self, stream: &serde_json::Value) -> Result<serde_json::Value, Box<dyn std::error::Error + Send + Sync>> {
+        Err("not supported".into())
+    }
+}
diff --git a/runtime/rust/prompty/src/model/prompty.rs b/runtime/rust/prompty/src/model/prompty.rs
index bf47f178..2597b83a 100644
--- a/runtime/rust/prompty/src/model/prompty.rs
+++ b/runtime/rust/prompty/src/model/prompty.rs
@@ -1,5 +1,9 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
 use super::model::Model;
@@ -10,7 +14,7 @@ use super::template::Template;
 
 use super::tool::Tool;
 
-/// A Prompty is a markdown file format for LLM prompts. The frontmatter defines structured metadata including model configuration, input/output schemas, tools, and template settings. The markdown body becomes the instructions.  This is the single root type for the Prompty schema — there is no abstract base class or kind discriminator. A .prompty file always produces a Prompty instance.
+/// A Prompty is a markdown file format for LLM prompts. The frontmatter defines structured metadata including model configuration, input/output schemas, tools, and template settings. The markdown body becomes the instructions. This is the single root type for the Prompty schema — there is no abstract base class or kind discriminator. A .prompty file always produces a Prompty instance.
 #[derive(Debug, Clone, Default)]
 pub struct Prompty {
     /// Human-readable name of the prompt
@@ -22,13 +26,13 @@ pub struct Prompty {
     /// Additional metadata including authors, tags, and other arbitrary properties
     pub metadata: serde_json::Value,
     /// Input parameters that participate in template rendering
-    pub inputs: serde_json::Value,
+    pub inputs: Vec<Property>,
     /// Expected output format and structure
-    pub outputs: serde_json::Value,
+    pub outputs: Vec<Property>,
     /// AI model configuration
     pub model: Model,
     /// Tools available for extended functionality
-    pub tools: serde_json::Value,
+    pub tools: Vec<Tool>,
     /// Template configuration for prompt rendering
     pub template: Option<Template>,
     /// Clear directions on what the prompt should do. In .prompty files, this comes from the markdown body.
@@ -59,48 +63,16 @@ impl Prompty {
     pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
         let value = ctx.process_input(value.clone());
         Self {
-            name: value
-                .get("name")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-                .to_string(),
-            display_name: value
-                .get("displayName")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string()),
-            description: value
-                .get("description")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string()),
-            metadata: value
-                .get("metadata")
-                .cloned()
-                .unwrap_or(serde_json::Value::Null),
-            inputs: value
-                .get("inputs")
-                .cloned()
-                .unwrap_or(serde_json::Value::Null),
-            outputs: value
-                .get("outputs")
-                .cloned()
-                .unwrap_or(serde_json::Value::Null),
-            model: value
-                .get("model")
-                .filter(|v| v.is_object() || v.is_array() || v.is_string())
-                .map(|v| Model::load_from_value(v, ctx))
-                .unwrap_or_default(),
-            tools: value
-                .get("tools")
-                .cloned()
-                .unwrap_or(serde_json::Value::Null),
-            template: value
-                .get("template")
-                .filter(|v| v.is_object() || v.is_array() || v.is_string())
-                .map(|v| Template::load_from_value(v, ctx)),
-            instructions: value
-                .get("instructions")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string()),
+            name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            display_name: value.get("displayName").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            description: value.get("description").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            metadata: value.get("metadata").cloned().unwrap_or(serde_json::Value::Null),
+            inputs: value.get("inputs").map(|v| Self::load_inputs(v, ctx)).unwrap_or_default(),
+            outputs: value.get("outputs").map(|v| Self::load_outputs(v, ctx)).unwrap_or_default(),
+            model: value.get("model").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| Model::load_from_value(v, ctx)).unwrap_or_default(),
+            tools: value.get("tools").map(|v| Self::load_tools(v, ctx)).unwrap_or_default(),
+            template: value.get("template").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| Template::load_from_value(v, ctx)),
+            instructions: value.get("instructions").and_then(|v| v.as_str()).map(|s| s.to_string()),
         }
     }
 
@@ -109,32 +81,24 @@ impl Prompty {
     /// Calls `ctx.process_dict` after serialization.
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
+        // Write base fields
         if !self.name.is_empty() {
-            result.insert(
-                "name".to_string(),
-                serde_json::Value::String(self.name.clone()),
-            );
+            result.insert("name".to_string(), serde_json::Value::String(self.name.clone()));
         }
         if let Some(ref val) = self.display_name {
-            result.insert(
-                "displayName".to_string(),
-                serde_json::Value::String(val.clone()),
-            );
+            result.insert("displayName".to_string(), serde_json::Value::String(val.clone()));
         }
         if let Some(ref val) = self.description {
-            result.insert(
-                "description".to_string(),
-                serde_json::Value::String(val.clone()),
-            );
+            result.insert("description".to_string(), serde_json::Value::String(val.clone()));
         }
         if !self.metadata.is_null() {
             result.insert("metadata".to_string(), self.metadata.clone());
         }
-        if !self.inputs.is_null() {
-            result.insert("inputs".to_string(), self.inputs.clone());
+        if !self.inputs.is_empty() {
+            result.insert("inputs".to_string(), Self::save_inputs(&self.inputs, ctx));
         }
-        if !self.outputs.is_null() {
-            result.insert("outputs".to_string(), self.outputs.clone());
+        if !self.outputs.is_empty() {
+            result.insert("outputs".to_string(), Self::save_outputs(&self.outputs, ctx));
         }
         {
             let nested = self.model.to_value(ctx);
@@ -142,8 +106,8 @@ impl Prompty {
                 result.insert("model".to_string(), nested);
             }
         }
-        if !self.tools.is_null() {
-            result.insert("tools".to_string(), self.tools.clone());
+        if !self.tools.is_empty() {
+            result.insert("tools".to_string(), Self::save_tools(&self.tools, ctx));
         }
         if let Some(ref val) = self.template {
             let nested = val.to_value(ctx);
@@ -152,10 +116,7 @@ impl Prompty {
             }
         }
         if let Some(ref val) = self.instructions {
-            result.insert(
-                "instructions".to_string(),
-                serde_json::Value::String(val.clone()),
-            );
+            result.insert("instructions".to_string(), serde_json::Value::String(val.clone()));
         }
         ctx.process_dict(serde_json::Value::Object(result))
     }
@@ -174,112 +135,129 @@ impl Prompty {
     pub fn as_metadata_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
         self.metadata.as_object()
     }
-    /// Returns typed `Vec<Property>` by parsing the stored JSON value.
+
+
+    /// Load a collection of Property from a JSON value.
     /// Handles both array format `[{...}]` and dict format `{"name": {...}}`.
-    /// Returns `None` if the field is null or cannot be parsed.
-    pub fn as_inputs(&self) -> Option<Vec<Property>> {
-        match &self.inputs {
-            serde_json::Value::Array(arr) => Some(
-                arr.iter()
-                    .map(|v| Property::load_from_value(v, &LoadContext::default()))
-                    .collect(),
-            ),
+    fn load_inputs(data: &serde_json::Value, ctx: &LoadContext) -> Vec<Property> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| Property::load_from_value(v, ctx)).collect()
+            }
+
             serde_json::Value::Object(obj) => {
-                let result: Vec<Property> = obj
-                    .iter()
+                obj.iter()
                     .filter_map(|(name, value)| {
                         if value.is_array() {
-                            // Invalid format: skip entries with array values.
-                            // 'inputs' must be a flat list or name-keyed dict.
                             return None;
                         }
                         let mut v = if value.is_object() {
                             value.clone()
                         } else {
-                            serde_json::json!({ "value": value })
+                            serde_json::json!({ "kind": value })
                         };
                         if let serde_json::Value::Object(ref mut m) = v {
-                            m.entry("name".to_string())
-                                .or_insert_with(|| serde_json::Value::String(name.clone()));
+                            m.entry("name".to_string()).or_insert_with(|| serde_json::Value::String(name.clone()));
                         }
-                        Some(Property::load_from_value(&v, &LoadContext::default()))
+                        Some(Property::load_from_value(&v, ctx))
                     })
-                    .collect();
-                Some(result)
+                    .collect()
             }
-            _ => None,
+            _ => Vec::new(),
+
         }
     }
-    /// Returns typed `Vec<Property>` by parsing the stored JSON value.
-    /// Handles both array format `[{...}]` and dict format `{"name": {...}}`.
-    /// Returns `None` if the field is null or cannot be parsed.
-    pub fn as_outputs(&self) -> Option<Vec<Property>> {
-        match &self.outputs {
-            serde_json::Value::Array(arr) => Some(
-                arr.iter()
-                    .map(|v| Property::load_from_value(v, &LoadContext::default()))
-                    .collect(),
-            ),
-            serde_json::Value::Object(obj) => {
-                let result: Vec<Property> = obj
-                    .iter()
-                    .filter_map(|(name, value)| {
-                        if value.is_array() {
-                            // Invalid format: skip entries with array values.
-                            // 'outputs' must be a flat list or name-keyed dict.
-                            return None;
-                        }
-                        let mut v = if value.is_object() {
-                            value.clone()
-                        } else {
-                            serde_json::json!({ "value": value })
-                        };
-                        if let serde_json::Value::Object(ref mut m) = v {
-                            m.entry("name".to_string())
-                                .or_insert_with(|| serde_json::Value::String(name.clone()));
-                        }
-                        Some(Property::load_from_value(&v, &LoadContext::default()))
-                    })
-                    .collect();
-                Some(result)
+
+    /// Save a collection of Property to a JSON value.
+    fn save_inputs(items: &[Property], ctx: &SaveContext) -> serde_json::Value {
+
+        if ctx.collection_format == "array" {
+            return serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>());
+        }
+        // Object format: use name as key
+        let mut result = serde_json::Map::new();
+        for item in items {
+            let mut item_data = match item.to_value(ctx) {
+                serde_json::Value::Object(m) => m,
+                other => { let mut m = serde_json::Map::new(); m.insert("value".to_string(), other); m },
+            };
+            if let Some(serde_json::Value::String(name)) = item_data.remove("name") {
+                result.insert(name, serde_json::Value::Object(item_data));
+            }
+        }
+        serde_json::Value::Object(result)
+
+    }
+
+    /// Load a collection of Property from a JSON value.
+    /// Handles both array format `[{...}]`.
+    fn load_outputs(data: &serde_json::Value, ctx: &LoadContext) -> Vec<Property> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| Property::load_from_value(v, ctx)).collect()
             }
-            _ => None,
+
+            _ => Vec::new(),
+
         }
     }
-    /// Returns typed `Vec<Tool>` by parsing the stored JSON value.
+
+    /// Save a collection of Property to a JSON value.
+    fn save_outputs(items: &[Property], ctx: &SaveContext) -> serde_json::Value {
+
+        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())
+
+    }
+
+    /// Load a collection of Tool from a JSON value.
     /// Handles both array format `[{...}]` and dict format `{"name": {...}}`.
-    /// Returns `None` if the field is null or cannot be parsed.
-    pub fn as_tools(&self) -> Option<Vec<Tool>> {
-        match &self.tools {
-            serde_json::Value::Array(arr) => Some(
-                arr.iter()
-                    .map(|v| Tool::load_from_value(v, &LoadContext::default()))
-                    .collect(),
-            ),
+    fn load_tools(data: &serde_json::Value, ctx: &LoadContext) -> Vec<Tool> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| Tool::load_from_value(v, ctx)).collect()
+            }
+
             serde_json::Value::Object(obj) => {
-                let result: Vec<Tool> = obj
-                    .iter()
+                obj.iter()
                     .filter_map(|(name, value)| {
                         if value.is_array() {
-                            // Invalid format: skip entries with array values.
-                            // 'tools' must be a flat list or name-keyed dict.
                             return None;
                         }
                         let mut v = if value.is_object() {
                             value.clone()
                         } else {
-                            serde_json::json!({ "value": value })
+                            serde_json::json!({ "kind": value })
                         };
                         if let serde_json::Value::Object(ref mut m) = v {
-                            m.entry("name".to_string())
-                                .or_insert_with(|| serde_json::Value::String(name.clone()));
+                            m.entry("name".to_string()).or_insert_with(|| serde_json::Value::String(name.clone()));
                         }
-                        Some(Tool::load_from_value(&v, &LoadContext::default()))
+                        Some(Tool::load_from_value(&v, ctx))
                     })
-                    .collect();
-                Some(result)
+                    .collect()
+            }
+            _ => Vec::new(),
+
+        }
+    }
+
+    /// Save a collection of Tool to a JSON value.
+    fn save_tools(items: &[Tool], ctx: &SaveContext) -> serde_json::Value {
+
+        if ctx.collection_format == "array" {
+            return serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>());
+        }
+        // Object format: use name as key
+        let mut result = serde_json::Map::new();
+        for item in items {
+            let mut item_data = match item.to_value(ctx) {
+                serde_json::Value::Object(m) => m,
+                other => { let mut m = serde_json::Map::new(); m.insert("value".to_string(), other); m },
+            };
+            if let Some(serde_json::Value::String(name)) = item_data.remove("name") {
+                result.insert(name, serde_json::Value::Object(item_data));
             }
-            _ => None,
         }
+        serde_json::Value::Object(result)
+
     }
 }
diff --git a/runtime/rust/prompty/src/model/property.rs b/runtime/rust/prompty/src/model/property.rs
index 8091f1fd..53c68154 100644
--- a/runtime/rust/prompty/src/model/property.rs
+++ b/runtime/rust/prompty/src/model/property.rs
@@ -1,7 +1,12 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
+
 /// Variant-specific data for [`Property`], discriminated by `kind`.
 #[derive(Debug, Clone)]
 pub enum PropertyKind {
@@ -13,7 +18,7 @@ pub enum PropertyKind {
     /// `kind` = `"object"`
     Object {
         /// The properties contained in the object
-        properties: serde_json::Value,
+        properties: Vec<Property>,
     },
     /// Wildcard / catch-all variant for unrecognized `kind` values.
     Custom {
@@ -29,7 +34,7 @@ impl Default for PropertyKind {
         }
     }
 }
-/// Represents a single property.  - This model defines the structure of properties that can be used in prompts, including their type, description, whether they are required, and other attributes. - It allows for the definition of dynamic inputs that can be filled with data and processed to generate prompts for AI models.
+/// Represents a single property. - This model defines the structure of properties that can be used in prompts, including their type, description, whether they are required, and other attributes. - It allows for the definition of dynamic inputs that can be filled with data and processed to generate prompts for AI models.
 #[derive(Debug, Clone, Default)]
 pub struct Property {
     /// Name of the property
@@ -72,58 +77,35 @@ impl Property {
     pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
         let value = ctx.process_input(value.clone());
         if let Some(value) = value.as_bool() {
-            let expansion = serde_json::json!({"kind":"boolean","example":value});
-            return Self::load_from_value(&expansion, ctx);
-        }
-        if let Some(value) = value.as_f64() {
-            let expansion = serde_json::json!({"kind":"float","example":value});
-            return Self::load_from_value(&expansion, ctx);
+            return Property { kind: PropertyKind::Custom { kind_name: "boolean".to_string() }, example: Some(value.into()), ..Default::default() };
         }
         if let Some(value) = value.as_i64() {
-            let expansion = serde_json::json!({"kind":"integer","example":value});
-            return Self::load_from_value(&expansion, ctx);
+            return Property { kind: PropertyKind::Custom { kind_name: "integer".to_string() }, example: Some(value.into()), ..Default::default() };
         }
         if let Some(s) = value.as_str() {
             let value = s.to_string();
-            let expansion = serde_json::json!({"kind":"string","example":value});
-            return Self::load_from_value(&expansion, ctx);
+            return Property { kind: PropertyKind::Custom { kind_name: "string".to_string() }, example: Some(value.into()), ..Default::default() };
         }
         let kind_str = value.get("kind").and_then(|v| v.as_str()).unwrap_or("");
         let kind = match kind_str {
             "array" => PropertyKind::Array {
-                items: value
-                    .get("items")
-                    .cloned()
-                    .unwrap_or(serde_json::Value::Null),
+                items: value.get("items").cloned().unwrap_or(serde_json::Value::Null),
             },
             "object" => PropertyKind::Object {
-                properties: value
-                    .get("properties")
-                    .cloned()
-                    .unwrap_or(serde_json::Value::Null),
+                properties: value.get("properties").map(|v| Self::load_properties(v, ctx)).unwrap_or_default(),
             },
             _ => PropertyKind::Custom {
                 kind_name: kind_str.to_string(),
             },
         };
         Self {
-            name: value
-                .get("name")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-                .to_string(),
-            description: value
-                .get("description")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string()),
+            name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            description: value.get("description").and_then(|v| v.as_str()).map(|s| s.to_string()),
             required: value.get("required").and_then(|v| v.as_bool()),
             default: value.get("default").cloned(),
             example: value.get("example").cloned(),
-            enum_values: value
-                .get("enumValues")
-                .and_then(|v| v.as_array())
-                .map(|arr| arr.to_vec()),
-            kind,
+            enum_values: value.get("enumValues").and_then(|v| v.as_array()).map(|arr| arr.to_vec()),
+            kind: kind,
         }
     }
 
@@ -142,57 +124,40 @@ impl Property {
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
         // Write the discriminator
-        result.insert(
-            "kind".to_string(),
-            serde_json::Value::String(self.kind_str().to_string()),
-        );
+        result.insert("kind".to_string(), serde_json::Value::String(self.kind_str().to_string()));
         // Write base fields
         if !self.name.is_empty() {
-            result.insert(
-                "name".to_string(),
-                serde_json::Value::String(self.name.clone()),
-            );
+            result.insert("name".to_string(), serde_json::Value::String(self.name.clone()));
         }
         if let Some(ref val) = self.description {
-            result.insert(
-                "description".to_string(),
-                serde_json::Value::String(val.clone()),
-            );
+            result.insert("description".to_string(), serde_json::Value::String(val.clone()));
         }
         if let Some(val) = self.required {
             result.insert("required".to_string(), serde_json::Value::Bool(val));
         }
         if let Some(ref val) = self.default {
-            result.insert(
-                "default".to_string(),
-                serde_json::to_value(val).unwrap_or(serde_json::Value::Null),
-            );
+            result.insert("default".to_string(), val.clone());
         }
         if let Some(ref val) = self.example {
-            result.insert(
-                "example".to_string(),
-                serde_json::to_value(val).unwrap_or(serde_json::Value::Null),
-            );
+            result.insert("example".to_string(), val.clone());
         }
         if let Some(ref items) = self.enum_values {
-            result.insert(
-                "enumValues".to_string(),
-                serde_json::to_value(items).unwrap_or(serde_json::Value::Null),
-            );
+            result.insert("enumValues".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
         }
         // Write variant-specific fields
         match &self.kind {
-            PropertyKind::Array { items, .. } => {
+            PropertyKind::Array { items,  .. } => {
                 if !items.is_null() {
                     result.insert("items".to_string(), items.clone());
                 }
             }
-            PropertyKind::Object { properties, .. } => {
-                if !properties.is_null() {
-                    result.insert("properties".to_string(), properties.clone());
+            PropertyKind::Object { properties,  .. } => {
+                if !properties.is_empty() {
+                    result.insert("properties".to_string(), serde_json::Value::Array(properties.iter().map(|item| item.to_value(ctx)).collect()));
                 }
             }
-            PropertyKind::Custom { kind_name: _, .. } => {}
+            PropertyKind::Custom { kind_name: _, .. } => {
+            }
         }
         ctx.process_dict(serde_json::Value::Object(result))
     }
@@ -206,4 +171,26 @@ impl Property {
     pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
         serde_yaml::to_string(&self.to_value(ctx))
     }
+
+    /// Load a collection of Property from a JSON value.
+    /// Handles both array format `[{...}]`.
+    fn load_properties(data: &serde_json::Value, ctx: &LoadContext) -> Vec<Property> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| Property::load_from_value(v, ctx)).collect()
+            }
+
+            _ => Vec::new(),
+
+        }
+    }
+
+    /// Save a collection of Property to a JSON value.
+    fn save_properties(items: &[Property], ctx: &SaveContext) -> serde_json::Value {
+
+        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())
+
+    }
 }
+
+
diff --git a/runtime/rust/prompty/src/model/renderer.rs b/runtime/rust/prompty/src/model/renderer.rs
new file mode 100644
index 00000000..183b8a0d
--- /dev/null
+++ b/runtime/rust/prompty/src/model/renderer.rs
@@ -0,0 +1,15 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+
+use super::prompty::Prompty;
+
+/// Renders a template string with input values to produce the final prompt text.
+#[async_trait::async_trait]
+pub trait Renderer: Send + Sync {
+    /// Render the template string with input values
+    async fn render(&self, agent: &Prompty, template: &String, inputs: &serde_json::Value) -> Result<String, Box<dyn std::error::Error + Send + Sync>>;
+}
diff --git a/runtime/rust/prompty/src/model/status_event_payload.rs b/runtime/rust/prompty/src/model/status_event_payload.rs
new file mode 100644
index 00000000..3a2dd125
--- /dev/null
+++ b/runtime/rust/prompty/src/model/status_event_payload.rs
@@ -0,0 +1,65 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Payload for "status" events — informational messages about loop progress.
+#[derive(Debug, Clone, Default)]
+pub struct StatusEventPayload {
+    /// Human-readable status message
+    pub message: String,
+}
+
+impl StatusEventPayload {
+    /// Create a new StatusEventPayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load StatusEventPayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load StatusEventPayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load StatusEventPayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            message: value.get("message").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+        }
+    }
+
+    /// Serialize StatusEventPayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.message.is_empty() {
+            result.insert("message".to_string(), serde_json::Value::String(self.message.clone()));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize StatusEventPayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize StatusEventPayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/stream_chunk.rs b/runtime/rust/prompty/src/model/stream_chunk.rs
new file mode 100644
index 00000000..3c4aae3c
--- /dev/null
+++ b/runtime/rust/prompty/src/model/stream_chunk.rs
@@ -0,0 +1,155 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+use super::tool_call::ToolCall;
+
+
+/// Variant-specific data for [`StreamChunk`], discriminated by `kind`.
+#[derive(Debug, Clone)]
+pub enum StreamChunkKind {
+    /// `kind` = `"text"`
+    TextChunk {
+        /// The text content of the chunk
+        value: String,
+    },
+    /// `kind` = `"thinking"`
+    ThinkingChunk {
+        /// The thinking content of the chunk
+        value: String,
+    },
+    /// `kind` = `"tool"`
+    ToolChunk {
+        /// The tool call data
+        tool_call: ToolCall,
+    },
+    /// `kind` = `"error"`
+    ErrorChunk {
+        /// The error message
+        message: String,
+    },
+}
+
+impl Default for StreamChunkKind {
+    fn default() -> Self {
+        StreamChunkKind::TextChunk {
+            value: String::from(""),
+        }
+    }
+}
+/// A chunk of data from a streaming LLM response. Stream chunks are discriminated on the `kind` field.
+#[derive(Debug, Clone, Default)]
+pub struct StreamChunk {
+    /// Variant-specific data, discriminated by `kind`.
+    pub kind: StreamChunkKind,
+}
+
+impl StreamChunk {
+    /// Create a new StreamChunk with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load StreamChunk from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load StreamChunk from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load StreamChunk from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        let kind_str = value.get("kind").and_then(|v| v.as_str()).unwrap_or("");
+        let kind = match kind_str {
+            "text" => StreamChunkKind::TextChunk {
+                value: value.get("value").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            },
+            "thinking" => StreamChunkKind::ThinkingChunk {
+                value: value.get("value").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            },
+            "tool" => StreamChunkKind::ToolChunk {
+                tool_call: value.get("toolCall").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ToolCall::load_from_value(v, ctx)).unwrap_or_default(),
+            },
+            "error" => StreamChunkKind::ErrorChunk {
+                message: value.get("message").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            },
+            _ => StreamChunkKind::default(),
+        };
+        Self {
+            kind: kind,
+        }
+    }
+
+    /// Returns the `kind` discriminator string for this instance.
+    pub fn kind_str(&self) -> &str {
+        match &self.kind {
+            StreamChunkKind::TextChunk { .. } => "text",
+            StreamChunkKind::ThinkingChunk { .. } => "thinking",
+            StreamChunkKind::ToolChunk { .. } => "tool",
+            StreamChunkKind::ErrorChunk { .. } => "error",
+        }
+    }
+
+    /// Serialize StreamChunk to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write the discriminator
+        result.insert("kind".to_string(), serde_json::Value::String(self.kind_str().to_string()));
+        // Write base fields
+        // Write variant-specific fields
+        match &self.kind {
+            StreamChunkKind::TextChunk { value,  .. } => {
+                if !value.is_empty() {
+                    result.insert("value".to_string(), serde_json::Value::String(value.clone()));
+                }
+            }
+            StreamChunkKind::ThinkingChunk { value,  .. } => {
+                if !value.is_empty() {
+                    result.insert("value".to_string(), serde_json::Value::String(value.clone()));
+                }
+            }
+            StreamChunkKind::ToolChunk { tool_call,  .. } => {
+                {
+                    let nested = tool_call.to_value(ctx);
+                    if !nested.is_null() {
+                        result.insert("toolCall".to_string(), nested);
+                    }
+                }
+            }
+            StreamChunkKind::ErrorChunk { message,  .. } => {
+                if !message.is_empty() {
+                    result.insert("message".to_string(), serde_json::Value::String(message.clone()));
+                }
+            }
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize StreamChunk to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize StreamChunk to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
+
+
+
+
diff --git a/runtime/rust/prompty/src/model/template.rs b/runtime/rust/prompty/src/model/template.rs
index 35e6f626..97dcef3a 100644
--- a/runtime/rust/prompty/src/model/template.rs
+++ b/runtime/rust/prompty/src/model/template.rs
@@ -1,12 +1,16 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
 use super::format_config::FormatConfig;
 
 use super::parser_config::ParserConfig;
 
-/// Template model for defining prompt templates.  This model specifies the rendering engine used for slot filling prompts, the parser used to process the rendered template into API-compatible format, and additional options for the template engine.  It allows for the creation of reusable templates that can be filled with dynamic data and processed to generate prompts for AI models.
+/// Template model for defining prompt templates. This model specifies the rendering engine used for slot filling prompts, the parser used to process the rendered template into API-compatible format, and additional options for the template engine. It allows for the creation of reusable templates that can be filled with dynamic data and processed to generate prompts for AI models.
 #[derive(Debug, Clone, Default)]
 pub struct Template {
     /// Template rendering engine used for slot filling prompts (e.g., mustache, jinja2)
@@ -39,16 +43,8 @@ impl Template {
     pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
         let value = ctx.process_input(value.clone());
         Self {
-            format: value
-                .get("format")
-                .filter(|v| v.is_object() || v.is_array() || v.is_string())
-                .map(|v| FormatConfig::load_from_value(v, ctx))
-                .unwrap_or_default(),
-            parser: value
-                .get("parser")
-                .filter(|v| v.is_object() || v.is_array() || v.is_string())
-                .map(|v| ParserConfig::load_from_value(v, ctx))
-                .unwrap_or_default(),
+            format: value.get("format").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| FormatConfig::load_from_value(v, ctx)).unwrap_or_default(),
+            parser: value.get("parser").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ParserConfig::load_from_value(v, ctx)).unwrap_or_default(),
         }
     }
 
@@ -57,6 +53,7 @@ impl Template {
     /// Calls `ctx.process_dict` after serialization.
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
+        // Write base fields
         {
             let nested = self.format.to_value(ctx);
             if !nested.is_null() {
diff --git a/runtime/rust/prompty/src/model/thinking_event_payload.rs b/runtime/rust/prompty/src/model/thinking_event_payload.rs
new file mode 100644
index 00000000..5cad99e5
--- /dev/null
+++ b/runtime/rust/prompty/src/model/thinking_event_payload.rs
@@ -0,0 +1,65 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Payload for "thinking" events — reasoning/chain-of-thought tokens.
+#[derive(Debug, Clone, Default)]
+pub struct ThinkingEventPayload {
+    /// The thinking/reasoning token text
+    pub token: String,
+}
+
+impl ThinkingEventPayload {
+    /// Create a new ThinkingEventPayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ThinkingEventPayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ThinkingEventPayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ThinkingEventPayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            token: value.get("token").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+        }
+    }
+
+    /// Serialize ThinkingEventPayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.token.is_empty() {
+            result.insert("token".to_string(), serde_json::Value::String(self.token.clone()));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ThinkingEventPayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ThinkingEventPayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/thread_marker.rs b/runtime/rust/prompty/src/model/thread_marker.rs
new file mode 100644
index 00000000..d1cbcfbd
--- /dev/null
+++ b/runtime/rust/prompty/src/model/thread_marker.rs
@@ -0,0 +1,71 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Positional marker for conversation history insertion during template rendering. During `prepare()`, nonce strings in rendered text are replaced with ThreadMarker objects. The pipeline then replaces them with actual conversation messages from the inputs.
+#[derive(Debug, Clone, Default)]
+pub struct ThreadMarker {
+    /// The input property name (e.g. 'conversation')
+    pub name: String,
+    /// The rich kind ('thread', 'image', 'file', 'audio')
+    pub kind: String,
+}
+
+impl ThreadMarker {
+    /// Create a new ThreadMarker with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ThreadMarker from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ThreadMarker from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ThreadMarker from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            kind: value.get("kind").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+        }
+    }
+
+    /// Serialize ThreadMarker to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.name.is_empty() {
+            result.insert("name".to_string(), serde_json::Value::String(self.name.clone()));
+        }
+        if !self.kind.is_empty() {
+            result.insert("kind".to_string(), serde_json::Value::String(self.kind.clone()));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ThreadMarker to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ThreadMarker to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/token_event_payload.rs b/runtime/rust/prompty/src/model/token_event_payload.rs
new file mode 100644
index 00000000..afb04269
--- /dev/null
+++ b/runtime/rust/prompty/src/model/token_event_payload.rs
@@ -0,0 +1,65 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Payload for "token" events — a single text token streamed from the LLM.
+#[derive(Debug, Clone, Default)]
+pub struct TokenEventPayload {
+    /// The streamed token text
+    pub token: String,
+}
+
+impl TokenEventPayload {
+    /// Create a new TokenEventPayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load TokenEventPayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load TokenEventPayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load TokenEventPayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            token: value.get("token").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+        }
+    }
+
+    /// Serialize TokenEventPayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.token.is_empty() {
+            result.insert("token".to_string(), serde_json::Value::String(self.token.clone()));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize TokenEventPayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize TokenEventPayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/token_usage.rs b/runtime/rust/prompty/src/model/token_usage.rs
new file mode 100644
index 00000000..5fc0370b
--- /dev/null
+++ b/runtime/rust/prompty/src/model/token_usage.rs
@@ -0,0 +1,99 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Tracks token consumption for a single LLM call. Provider-specific field names (e.g., OpenAI's `prompt_tokens` vs Anthropic's `input_tokens`) are mapped via `knownAs` augments in the wire directory.
+#[derive(Debug, Clone, Default, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TokenUsage {
+    /// Number of tokens in the prompt/input sent to the model
+    pub prompt_tokens: Option<i32>,
+    /// Number of tokens generated in the model's completion/output
+    pub completion_tokens: Option<i32>,
+    /// Total tokens consumed (prompt + completion). May be provided by the API or computed.
+    pub total_tokens: Option<i32>,
+}
+
+impl TokenUsage {
+    /// Create a new TokenUsage with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load TokenUsage from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load TokenUsage from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load TokenUsage from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            prompt_tokens: value.get("promptTokens").and_then(|v| v.as_i64()).map(|v| v as i32),
+            completion_tokens: value.get("completionTokens").and_then(|v| v.as_i64()).map(|v| v as i32),
+            total_tokens: value.get("totalTokens").and_then(|v| v.as_i64()).map(|v| v as i32),
+        }
+    }
+
+    /// Serialize TokenUsage to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if let Some(val) = self.prompt_tokens {
+            result.insert("promptTokens".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
+        }
+        if let Some(val) = self.completion_tokens {
+            result.insert("completionTokens".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
+        }
+        if let Some(val) = self.total_tokens {
+            result.insert("totalTokens".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize TokenUsage to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize TokenUsage to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+
+    /// Convert to provider-specific wire format.
+    pub fn to_wire(&self, provider: &str) -> serde_json::Value {
+        let data = serde_json::to_value(self).unwrap_or_default();
+        let mut result = serde_json::Map::new();
+        let wire_map: std::collections::HashMap<&str, std::collections::HashMap<&str, &str>> = std::collections::HashMap::from([
+            ("promptTokens", std::collections::HashMap::from([("openai", "prompt_tokens"), ("anthropic", "input_tokens")])),
+            ("completionTokens", std::collections::HashMap::from([("openai", "completion_tokens"), ("anthropic", "output_tokens")])),
+            ("totalTokens", std::collections::HashMap::from([("openai", "total_tokens")])),
+        ]);
+        if let serde_json::Value::Object(map) = data {
+            for (key, value) in map {
+                if let Some(mapping) = wire_map.get(key.as_str()) {
+                    if let Some(wire_name) = mapping.get(provider) {
+                        result.insert(wire_name.to_string(), value);
+                    }
+                }
+            }
+        }
+        serde_json::Value::Object(result)
+    }
+}
diff --git a/runtime/rust/prompty/src/model/tool.rs b/runtime/rust/prompty/src/model/tool.rs
index 1f2fb372..66ca111e 100644
--- a/runtime/rust/prompty/src/model/tool.rs
+++ b/runtime/rust/prompty/src/model/tool.rs
@@ -1,18 +1,27 @@
+
+
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
+#![allow(unused_imports, dead_code)]
+
 use super::context::{LoadContext, SaveContext};
 
 use super::binding::Binding;
 
+use super::connection::Connection;
+
 use super::mcp_approval_mode::McpApprovalMode;
 
+use super::property::Property;
+
+
 /// Variant-specific data for [`Tool`], discriminated by `kind`.
 #[derive(Debug, Clone)]
 pub enum ToolKind {
     /// `kind` = `"function"`
     Function {
         /// Parameters accepted by the function tool
-        parameters: serde_json::Value,
+        parameters: Vec<Property>,
         /// Indicates whether the function tool enforces strict validation on its parameters
         strict: Option<bool>,
     },
@@ -71,7 +80,7 @@ pub struct Tool {
     /// A short description of the tool for metadata purposes
     pub description: Option<String>,
     /// Tool argument bindings to input properties
-    pub bindings: serde_json::Value,
+    pub bindings: Vec<Binding>,
     /// Variant-specific data, discriminated by `kind`.
     pub kind: ToolKind,
 }
@@ -102,90 +111,35 @@ impl Tool {
         let kind_str = value.get("kind").and_then(|v| v.as_str()).unwrap_or("");
         let kind = match kind_str {
             "function" => ToolKind::Function {
-                parameters: value
-                    .get("parameters")
-                    .cloned()
-                    .unwrap_or(serde_json::Value::Null),
+                parameters: value.get("parameters").map(|v| Self::load_parameters(v, ctx)).unwrap_or_default(),
                 strict: value.get("strict").and_then(|v| v.as_bool()),
             },
             "mcp" => ToolKind::Mcp {
-                connection: value
-                    .get("connection")
-                    .cloned()
-                    .unwrap_or(serde_json::Value::Null),
-                server_name: value
-                    .get("serverName")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                server_description: value
-                    .get("serverDescription")
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.to_string()),
-                approval_mode: value
-                    .get("approvalMode")
-                    .filter(|v| v.is_object() || v.is_array() || v.is_string())
-                    .map(|v| McpApprovalMode::load_from_value(v, ctx))
-                    .unwrap_or_default(),
-                allowed_tools: value
-                    .get("allowedTools")
-                    .and_then(|v| v.as_array())
-                    .map(|arr| {
-                        arr.iter()
-                            .filter_map(|v| v.as_str().map(|s| s.to_string()))
-                            .collect()
-                    }),
+                connection: value.get("connection").cloned().unwrap_or(serde_json::Value::Null),
+                server_name: value.get("serverName").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                server_description: value.get("serverDescription").and_then(|v| v.as_str()).map(|s| s.to_string()),
+                approval_mode: value.get("approvalMode").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| McpApprovalMode::load_from_value(v, ctx)).unwrap_or_default(),
+                allowed_tools: value.get("allowedTools").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()),
             },
             "openapi" => ToolKind::OpenApi {
-                connection: value
-                    .get("connection")
-                    .cloned()
-                    .unwrap_or(serde_json::Value::Null),
-                specification: value
-                    .get("specification")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
+                connection: value.get("connection").cloned().unwrap_or(serde_json::Value::Null),
+                specification: value.get("specification").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
             },
             "prompty" => ToolKind::Prompty {
-                path: value
-                    .get("path")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
-                mode: value
-                    .get("mode")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string(),
+                path: value.get("path").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                mode: value.get("mode").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
             },
             _ => ToolKind::Custom {
-                connection: value
-                    .get("connection")
-                    .cloned()
-                    .unwrap_or(serde_json::Value::Null),
-                options: value
-                    .get("options")
-                    .cloned()
-                    .unwrap_or(serde_json::Value::Null),
+                connection: value.get("connection").cloned().unwrap_or(serde_json::Value::Null),
+                options: value.get("options").cloned().unwrap_or(serde_json::Value::Null),
                 kind_name: kind_str.to_string(),
             },
         };
         Self {
-            name: value
-                .get("name")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-                .to_string(),
-            description: value
-                .get("description")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string()),
-            bindings: value
-                .get("bindings")
-                .cloned()
-                .unwrap_or(serde_json::Value::Null),
-            kind,
+            name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            description: value.get("description").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            bindings: value.get("bindings").map(|v| Self::load_bindings(v, ctx)).unwrap_or_default(),
+            kind: kind,
         }
     }
 
@@ -206,60 +160,36 @@ impl Tool {
     pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
         let mut result = serde_json::Map::new();
         // Write the discriminator
-        result.insert(
-            "kind".to_string(),
-            serde_json::Value::String(self.kind_str().to_string()),
-        );
+        result.insert("kind".to_string(), serde_json::Value::String(self.kind_str().to_string()));
         // Write base fields
         if !self.name.is_empty() {
-            result.insert(
-                "name".to_string(),
-                serde_json::Value::String(self.name.clone()),
-            );
+            result.insert("name".to_string(), serde_json::Value::String(self.name.clone()));
         }
         if let Some(ref val) = self.description {
-            result.insert(
-                "description".to_string(),
-                serde_json::Value::String(val.clone()),
-            );
+            result.insert("description".to_string(), serde_json::Value::String(val.clone()));
         }
-        if !self.bindings.is_null() {
-            result.insert("bindings".to_string(), self.bindings.clone());
+        if !self.bindings.is_empty() {
+            result.insert("bindings".to_string(), Self::save_bindings(&self.bindings, ctx));
         }
         // Write variant-specific fields
         match &self.kind {
-            ToolKind::Function {
-                parameters, strict, ..
-            } => {
-                if !parameters.is_null() {
-                    result.insert("parameters".to_string(), parameters.clone());
+            ToolKind::Function { parameters, strict,  .. } => {
+                if !parameters.is_empty() {
+                    result.insert("parameters".to_string(), serde_json::Value::Array(parameters.iter().map(|item| item.to_value(ctx)).collect()));
                 }
                 if let Some(val) = strict {
                     result.insert("strict".to_string(), serde_json::Value::Bool(*val));
                 }
             }
-            ToolKind::Mcp {
-                connection,
-                server_name,
-                server_description,
-                approval_mode,
-                allowed_tools,
-                ..
-            } => {
+            ToolKind::Mcp { connection, server_name, server_description, approval_mode, allowed_tools,  .. } => {
                 if !connection.is_null() {
                     result.insert("connection".to_string(), connection.clone());
                 }
                 if !server_name.is_empty() {
-                    result.insert(
-                        "serverName".to_string(),
-                        serde_json::Value::String(server_name.clone()),
-                    );
+                    result.insert("serverName".to_string(), serde_json::Value::String(server_name.clone()));
                 }
                 if let Some(val) = server_description {
-                    result.insert(
-                        "serverDescription".to_string(),
-                        serde_json::Value::String(val.clone()),
-                    );
+                    result.insert("serverDescription".to_string(), serde_json::Value::String(val.clone()));
                 }
                 {
                     let nested = approval_mode.to_value(ctx);
@@ -268,28 +198,18 @@ impl Tool {
                     }
                 }
                 if let Some(items) = allowed_tools {
-                    result.insert(
-                        "allowedTools".to_string(),
-                        serde_json::to_value(items).unwrap_or(serde_json::Value::Null),
-                    );
+                    result.insert("allowedTools".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
                 }
             }
-            ToolKind::OpenApi {
-                connection,
-                specification,
-                ..
-            } => {
+            ToolKind::OpenApi { connection, specification,  .. } => {
                 if !connection.is_null() {
                     result.insert("connection".to_string(), connection.clone());
                 }
                 if !specification.is_empty() {
-                    result.insert(
-                        "specification".to_string(),
-                        serde_json::Value::String(specification.clone()),
-                    );
+                    result.insert("specification".to_string(), serde_json::Value::String(specification.clone()));
                 }
             }
-            ToolKind::Prompty { path, mode, .. } => {
+            ToolKind::Prompty { path, mode,  .. } => {
                 if !path.is_empty() {
                     result.insert("path".to_string(), serde_json::Value::String(path.clone()));
                 }
@@ -297,12 +217,7 @@ impl Tool {
                     result.insert("mode".to_string(), serde_json::Value::String(mode.clone()));
                 }
             }
-            ToolKind::Custom {
-                connection,
-                options,
-                kind_name: _,
-                ..
-            } => {
+            ToolKind::Custom { connection, options, kind_name: _, .. } => {
                 if !connection.is_null() {
                     result.insert("connection".to_string(), connection.clone());
                 }
@@ -323,40 +238,81 @@ impl Tool {
     pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
         serde_yaml::to_string(&self.to_value(ctx))
     }
-    /// Returns typed `Vec<Binding>` by parsing the stored JSON value.
+
+    /// Load a collection of Binding from a JSON value.
     /// Handles both array format `[{...}]` and dict format `{"name": {...}}`.
-    /// Returns `None` if the field is null or cannot be parsed.
-    pub fn as_bindings(&self) -> Option<Vec<Binding>> {
-        match &self.bindings {
-            serde_json::Value::Array(arr) => Some(
-                arr.iter()
-                    .map(|v| Binding::load_from_value(v, &LoadContext::default()))
-                    .collect(),
-            ),
+    fn load_bindings(data: &serde_json::Value, ctx: &LoadContext) -> Vec<Binding> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| Binding::load_from_value(v, ctx)).collect()
+            }
+
             serde_json::Value::Object(obj) => {
-                let result: Vec<Binding> = obj
-                    .iter()
+                obj.iter()
                     .filter_map(|(name, value)| {
                         if value.is_array() {
-                            // Invalid format: skip entries with array values.
-                            // 'bindings' must be a flat list or name-keyed dict.
                             return None;
                         }
                         let mut v = if value.is_object() {
                             value.clone()
                         } else {
-                            serde_json::json!({ "value": value })
+                            serde_json::json!({ "input": value })
                         };
                         if let serde_json::Value::Object(ref mut m) = v {
-                            m.entry("name".to_string())
-                                .or_insert_with(|| serde_json::Value::String(name.clone()));
+                            m.entry("name".to_string()).or_insert_with(|| serde_json::Value::String(name.clone()));
                         }
-                        Some(Binding::load_from_value(&v, &LoadContext::default()))
+                        Some(Binding::load_from_value(&v, ctx))
                     })
-                    .collect();
-                Some(result)
+                    .collect()
             }
-            _ => None,
+            _ => Vec::new(),
+
         }
     }
+
+    /// Save a collection of Binding to a JSON value.
+    fn save_bindings(items: &[Binding], ctx: &SaveContext) -> serde_json::Value {
+
+        if ctx.collection_format == "array" {
+            return serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>());
+        }
+        // Object format: use name as key
+        let mut result = serde_json::Map::new();
+        for item in items {
+            let mut item_data = match item.to_value(ctx) {
+                serde_json::Value::Object(m) => m,
+                other => { let mut m = serde_json::Map::new(); m.insert("value".to_string(), other); m },
+            };
+            if let Some(serde_json::Value::String(name)) = item_data.remove("name") {
+                result.insert(name, serde_json::Value::Object(item_data));
+            }
+        }
+        serde_json::Value::Object(result)
+
+    }
+
+    /// Load a collection of Property from a JSON value.
+    /// Handles both array format `[{...}]`.
+    fn load_parameters(data: &serde_json::Value, ctx: &LoadContext) -> Vec<Property> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| Property::load_from_value(v, ctx)).collect()
+            }
+
+            _ => Vec::new(),
+
+        }
+    }
+
+    /// Save a collection of Property to a JSON value.
+    fn save_parameters(items: &[Property], ctx: &SaveContext) -> serde_json::Value {
+
+        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())
+
+    }
 }
+
+
+
+
+
diff --git a/runtime/rust/prompty/src/model/tool_call.rs b/runtime/rust/prompty/src/model/tool_call.rs
new file mode 100644
index 00000000..f9b3f9f5
--- /dev/null
+++ b/runtime/rust/prompty/src/model/tool_call.rs
@@ -0,0 +1,77 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// A tool call requested by the LLM. Contains the function name and serialized arguments that should be dispatched to the appropriate tool handler.
+#[derive(Debug, Clone, Default)]
+pub struct ToolCall {
+    /// The unique identifier of the tool call
+    pub id: String,
+    /// The name of the tool to call
+    pub name: String,
+    /// The serialized JSON arguments for the tool call
+    pub arguments: String,
+}
+
+impl ToolCall {
+    /// Create a new ToolCall with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ToolCall from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolCall from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolCall from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            id: value.get("id").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            arguments: value.get("arguments").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+        }
+    }
+
+    /// Serialize ToolCall to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.id.is_empty() {
+            result.insert("id".to_string(), serde_json::Value::String(self.id.clone()));
+        }
+        if !self.name.is_empty() {
+            result.insert("name".to_string(), serde_json::Value::String(self.name.clone()));
+        }
+        if !self.arguments.is_empty() {
+            result.insert("arguments".to_string(), serde_json::Value::String(self.arguments.clone()));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ToolCall to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ToolCall to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/tool_call_start_payload.rs b/runtime/rust/prompty/src/model/tool_call_start_payload.rs
new file mode 100644
index 00000000..dd8203bb
--- /dev/null
+++ b/runtime/rust/prompty/src/model/tool_call_start_payload.rs
@@ -0,0 +1,71 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+/// Payload for "tool_call_start" events — the LLM has requested a tool call.
+#[derive(Debug, Clone, Default)]
+pub struct ToolCallStartPayload {
+    /// The name of the tool being called
+    pub name: String,
+    /// The serialized JSON arguments for the tool call
+    pub arguments: String,
+}
+
+impl ToolCallStartPayload {
+    /// Create a new ToolCallStartPayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ToolCallStartPayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolCallStartPayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolCallStartPayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            arguments: value.get("arguments").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+        }
+    }
+
+    /// Serialize ToolCallStartPayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.name.is_empty() {
+            result.insert("name".to_string(), serde_json::Value::String(self.name.clone()));
+        }
+        if !self.arguments.is_empty() {
+            result.insert("arguments".to_string(), serde_json::Value::String(self.arguments.clone()));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ToolCallStartPayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ToolCallStartPayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/tool_context.rs b/runtime/rust/prompty/src/model/tool_context.rs
new file mode 100644
index 00000000..c558a23a
--- /dev/null
+++ b/runtime/rust/prompty/src/model/tool_context.rs
@@ -0,0 +1,99 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+use super::message::Message;
+
+/// Context passed to tool handlers during agent loop execution. Provides access to the agent configuration, current conversation state, and arbitrary metadata for tool implementations that need broader context.
+#[derive(Debug, Clone, Default)]
+pub struct ToolContext {
+    /// The current conversation messages at the point of tool invocation
+    pub messages: Vec<Message>,
+    /// Optional metadata for tool-specific context (e.g., user session info)
+    pub metadata: serde_json::Value,
+}
+
+impl ToolContext {
+    /// Create a new ToolContext with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ToolContext from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolContext from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolContext from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            messages: value.get("messages").map(|v| Self::load_messages(v, ctx)).unwrap_or_default(),
+            metadata: value.get("metadata").cloned().unwrap_or(serde_json::Value::Null),
+        }
+    }
+
+    /// Serialize ToolContext to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.messages.is_empty() {
+            result.insert("messages".to_string(), Self::save_messages(&self.messages, ctx));
+        }
+        if !self.metadata.is_null() {
+            result.insert("metadata".to_string(), self.metadata.clone());
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ToolContext to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ToolContext to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+    /// Returns typed reference to the map if the field is an object.
+    /// Returns `None` if the field is null or not an object.
+    pub fn as_metadata_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
+        self.metadata.as_object()
+    }
+
+
+    /// Load a collection of Message from a JSON value.
+    /// Handles both array format `[{...}]`.
+    fn load_messages(data: &serde_json::Value, ctx: &LoadContext) -> Vec<Message> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| Message::load_from_value(v, ctx)).collect()
+            }
+
+            _ => Vec::new(),
+
+        }
+    }
+
+    /// Save a collection of Message to a JSON value.
+    fn save_messages(items: &[Message], ctx: &SaveContext) -> serde_json::Value {
+
+        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())
+
+    }
+}
diff --git a/runtime/rust/prompty/src/model/tool_dispatch_result.rs b/runtime/rust/prompty/src/model/tool_dispatch_result.rs
new file mode 100644
index 00000000..056cde0f
--- /dev/null
+++ b/runtime/rust/prompty/src/model/tool_dispatch_result.rs
@@ -0,0 +1,82 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+use super::tool_result::ToolResult;
+
+/// The result of dispatching a single tool call. Pairs the tool call identifier with the tool's name and result for correlation in the agent loop's message assembly.
+#[derive(Debug, Clone, Default)]
+pub struct ToolDispatchResult {
+    /// The tool call ID from the LLM response, used to correlate results
+    pub tool_call_id: String,
+    /// The name of the tool that was called
+    pub name: String,
+    /// The result produced by the tool handler
+    pub result: ToolResult,
+}
+
+impl ToolDispatchResult {
+    /// Create a new ToolDispatchResult with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ToolDispatchResult from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolDispatchResult from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolDispatchResult from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            tool_call_id: value.get("toolCallId").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            result: value.get("result").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ToolResult::load_from_value(v, ctx)).unwrap_or_default(),
+        }
+    }
+
+    /// Serialize ToolDispatchResult to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.tool_call_id.is_empty() {
+            result.insert("toolCallId".to_string(), serde_json::Value::String(self.tool_call_id.clone()));
+        }
+        if !self.name.is_empty() {
+            result.insert("name".to_string(), serde_json::Value::String(self.name.clone()));
+        }
+        {
+            let nested = self.result.to_value(ctx);
+            if !nested.is_null() {
+                result.insert("result".to_string(), nested);
+            }
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ToolDispatchResult to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ToolDispatchResult to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/tool_result.rs b/runtime/rust/prompty/src/model/tool_result.rs
new file mode 100644
index 00000000..19172c0a
--- /dev/null
+++ b/runtime/rust/prompty/src/model/tool_result.rs
@@ -0,0 +1,96 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+use super::content_part::{ContentPart, ContentPartKind};
+
+/// The result of a tool execution. Contains a list of content parts, enabling rich tool results (text, images, files, audio) rather than just strings. Implementations MUST support conversion from a plain string to a ToolResult containing a single TextPart for backward compatibility.
+#[derive(Debug, Clone, Default)]
+pub struct ToolResult {
+    /// The content parts of the tool result
+    pub parts: Vec<ContentPart>,
+}
+
+impl ToolResult {
+    /// Create a new ToolResult with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ToolResult from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolResult from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolResult from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            parts: value.get("parts").map(|v| Self::load_parts(v, ctx)).unwrap_or_default(),
+        }
+    }
+
+    /// Serialize ToolResult to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.parts.is_empty() {
+            result.insert("parts".to_string(), Self::save_parts(&self.parts, ctx));
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ToolResult to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ToolResult to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+
+    /// Load a collection of ContentPart from a JSON value.
+    /// Handles both array format `[{...}]`.
+    fn load_parts(data: &serde_json::Value, ctx: &LoadContext) -> Vec<ContentPart> {
+        match data {
+            serde_json::Value::Array(arr) => {
+                arr.iter().map(|v| ContentPart::load_from_value(v, ctx)).collect()
+            }
+
+            _ => Vec::new(),
+
+        }
+    }
+
+    /// Save a collection of ContentPart to a JSON value.
+    fn save_parts(items: &[ContentPart], ctx: &SaveContext) -> serde_json::Value {
+
+        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())
+
+    }
+    /// Create a ToolResult with preset field values.
+    pub fn text(value: impl Into<String>) -> Self {
+        ToolResult { parts: vec![ContentPart { kind: ContentPartKind::TextPart { value: value.into() }, ..Default::default() }], ..Default::default() }
+    }
+}
+/// Helpers for [`ToolResult`]. Implement in a separate file.
+pub trait ToolResultHelpers {
+    /// Concatenate all TextPart values joined by newline
+    fn text(&self) -> String;
+}
diff --git a/runtime/rust/prompty/src/model/tool_result_payload.rs b/runtime/rust/prompty/src/model/tool_result_payload.rs
new file mode 100644
index 00000000..8ad7e2de
--- /dev/null
+++ b/runtime/rust/prompty/src/model/tool_result_payload.rs
@@ -0,0 +1,76 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+use super::tool_result::ToolResult;
+
+/// Payload for "tool_result" events — a tool has returned its result.
+#[derive(Debug, Clone, Default)]
+pub struct ToolResultPayload {
+    /// The name of the tool that produced the result
+    pub name: String,
+    /// The tool's result
+    pub result: ToolResult,
+}
+
+impl ToolResultPayload {
+    /// Create a new ToolResultPayload with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load ToolResultPayload from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolResultPayload from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load ToolResultPayload from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            name: value.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            result: value.get("result").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ToolResult::load_from_value(v, ctx)).unwrap_or_default(),
+        }
+    }
+
+    /// Serialize ToolResultPayload to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if !self.name.is_empty() {
+            result.insert("name".to_string(), serde_json::Value::String(self.name.clone()));
+        }
+        {
+            let nested = self.result.to_value(ctx);
+            if !nested.is_null() {
+                result.insert("result".to_string(), nested);
+            }
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize ToolResultPayload to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize ToolResultPayload to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model/turn_options.rs b/runtime/rust/prompty/src/model/turn_options.rs
new file mode 100644
index 00000000..a108d91a
--- /dev/null
+++ b/runtime/rust/prompty/src/model/turn_options.rs
@@ -0,0 +1,106 @@
+
+
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+#![allow(unused_imports, dead_code)]
+
+use super::context::{LoadContext, SaveContext};
+
+use super::compaction_config::CompactionConfig;
+
+/// Configuration for the agent loop's turn() function. Controls iteration limits, retry policy, context management, and execution behavior. Runtimes accept these as either a TurnOptions object or individual keyword/named parameters — the TypeSpec model defines the canonical field set.
+#[derive(Debug, Clone, Default)]
+pub struct TurnOptions {
+    /// Maximum number of tool-call iterations before the loop terminates
+    pub max_iterations: Option<i32>,
+    /// Maximum number of LLM call retries on transient failure within a single iteration
+    pub max_llm_retries: Option<i32>,
+    /// Character budget for the context window. When set, the loop trims older messages to stay within budget before each LLM call. System messages are never dropped.
+    pub context_budget: Option<i32>,
+    /// Whether to execute multiple tool calls concurrently when the LLM returns several in one response
+    pub parallel_tool_calls: Option<bool>,
+    /// When true, return the raw LLM response without processor post-processing
+    pub raw: Option<bool>,
+    /// Turn number for trace labeling. Useful when the caller maintains an outer conversation loop.
+    pub turn: Option<i32>,
+    /// Context compaction configuration. Controls how messages are summarized when the context window exceeds the budget.
+    pub compaction: Option<CompactionConfig>,
+}
+
+impl TurnOptions {
+    /// Create a new TurnOptions with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load TurnOptions from a JSON string.
+    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(json)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load TurnOptions from a YAML string.
+    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
+        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
+        Ok(Self::load_from_value(&value, ctx))
+    }
+
+    /// Load TurnOptions from a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_input` before field extraction.
+    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
+        let value = ctx.process_input(value.clone());
+        Self {
+            max_iterations: value.get("maxIterations").and_then(|v| v.as_i64()).map(|v| v as i32),
+            max_llm_retries: value.get("maxLlmRetries").and_then(|v| v.as_i64()).map(|v| v as i32),
+            context_budget: value.get("contextBudget").and_then(|v| v.as_i64()).map(|v| v as i32),
+            parallel_tool_calls: value.get("parallelToolCalls").and_then(|v| v.as_bool()),
+            raw: value.get("raw").and_then(|v| v.as_bool()),
+            turn: value.get("turn").and_then(|v| v.as_i64()).map(|v| v as i32),
+            compaction: value.get("compaction").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| CompactionConfig::load_from_value(v, ctx)),
+        }
+    }
+
+    /// Serialize TurnOptions to a `serde_json::Value`.
+    ///
+    /// Calls `ctx.process_dict` after serialization.
+    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
+        let mut result = serde_json::Map::new();
+        // Write base fields
+        if let Some(val) = self.max_iterations {
+            result.insert("maxIterations".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
+        }
+        if let Some(val) = self.max_llm_retries {
+            result.insert("maxLlmRetries".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
+        }
+        if let Some(val) = self.context_budget {
+            result.insert("contextBudget".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
+        }
+        if let Some(val) = self.parallel_tool_calls {
+            result.insert("parallelToolCalls".to_string(), serde_json::Value::Bool(val));
+        }
+        if let Some(val) = self.raw {
+            result.insert("raw".to_string(), serde_json::Value::Bool(val));
+        }
+        if let Some(val) = self.turn {
+            result.insert("turn".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));
+        }
+        if let Some(ref val) = self.compaction {
+            let nested = val.to_value(ctx);
+            if !nested.is_null() {
+                result.insert("compaction".to_string(), nested);
+            }
+        }
+        ctx.process_dict(serde_json::Value::Object(result))
+    }
+
+    /// Serialize TurnOptions to a JSON string.
+    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(&self.to_value(ctx))
+    }
+
+    /// Serialize TurnOptions to a YAML string.
+    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(&self.to_value(ctx))
+    }
+}
diff --git a/runtime/rust/prompty/src/model_ext.rs b/runtime/rust/prompty/src/model_ext.rs
new file mode 100644
index 00000000..61c2493f
--- /dev/null
+++ b/runtime/rust/prompty/src/model_ext.rs
@@ -0,0 +1,97 @@
+//! Extension methods for generated model types.
+//!
+//! The TypeSpec emitter generates the model structs in `model/`. This module
+//! adds convenience accessors used by the pipeline and other hand-written code.
+
+use crate::model::{ContentPartKind, Message, MessageHelpers, Property, Prompty, Tool, ToolResult, ToolResultHelpers};
+
+// ---------------------------------------------------------------------------
+// Prompty helpers
+// ---------------------------------------------------------------------------
+
+impl Prompty {
+    /// Returns a reference to the input properties, or `None` if empty.
+    pub fn as_inputs(&self) -> Option<&Vec<Property>> {
+        if self.inputs.is_empty() {
+            None
+        } else {
+            Some(&self.inputs)
+        }
+    }
+
+    /// Returns a reference to the output properties, or `None` if empty.
+    pub fn as_outputs(&self) -> Option<&Vec<Property>> {
+        if self.outputs.is_empty() {
+            None
+        } else {
+            Some(&self.outputs)
+        }
+    }
+
+    /// Returns a reference to the tools list, or `None` if empty.
+    pub fn as_tools(&self) -> Option<&Vec<Tool>> {
+        if self.tools.is_empty() {
+            None
+        } else {
+            Some(&self.tools)
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// MessageHelpers — concatenate TextPart values
+// ---------------------------------------------------------------------------
+
+impl MessageHelpers for Message {
+    fn to_text_content(&self) -> serde_json::Value {
+        // If all parts are text, return a single joined string.
+        // Otherwise return an array of content part dicts for wire serialization.
+        let all_text = self.parts.iter().all(|p| matches!(&p.kind, ContentPartKind::TextPart { .. }));
+        if all_text {
+            let text = self
+                .parts
+                .iter()
+                .filter_map(|p| match &p.kind {
+                    ContentPartKind::TextPart { value } => Some(value.as_str()),
+                    _ => None,
+                })
+                .collect::<Vec<_>>()
+                .join("\n");
+            serde_json::Value::String(text)
+        } else {
+            use crate::model::context::SaveContext;
+            let ctx = SaveContext::default();
+            serde_json::Value::Array(
+                self.parts.iter().map(|p| p.to_value(&ctx)).collect(),
+            )
+        }
+    }
+
+    fn text(&self) -> String {
+        self.parts
+            .iter()
+            .filter_map(|p| match &p.kind {
+                ContentPartKind::TextPart { value } => Some(value.as_str()),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}
+
+// ---------------------------------------------------------------------------
+// ToolResultHelpers — concatenate TextPart values
+// ---------------------------------------------------------------------------
+
+impl ToolResultHelpers for ToolResult {
+    fn text(&self) -> String {
+        self.parts
+            .iter()
+            .filter_map(|p| match &p.kind {
+                ContentPartKind::TextPart { value } => Some(value.as_str()),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}
diff --git a/runtime/rust/prompty/src/pipeline.rs b/runtime/rust/prompty/src/pipeline.rs
index 27158de9..05690005 100644
--- a/runtime/rust/prompty/src/pipeline.rs
+++ b/runtime/rust/prompty/src/pipeline.rs
@@ -229,7 +229,7 @@ pub fn validate_inputs(
         .as_object_mut()
         .ok_or_else(|| InvokerError::Validation("inputs must be a JSON object".into()))?;
 
-    for prop in &props {
+    for prop in props {
         if prop.name.is_empty() {
             continue;
         }
@@ -1321,12 +1321,7 @@ pub async fn turn_from_path(
     turn(&agent, inputs, options).await
 }
 fn has_any_tools(agent: &Prompty) -> bool {
-    if let Some(arr) = agent.tools.as_array() {
-        if !arr.is_empty() {
-            return true;
-        }
-    }
-    false
+    !agent.tools.is_empty()
 }
 
 /// Execute a single LLM attempt (streaming or non-streaming).
diff --git a/runtime/rust/prompty/src/renderers/common.rs b/runtime/rust/prompty/src/renderers/common.rs
index 8b0a3083..2b627f2e 100644
--- a/runtime/rust/prompty/src/renderers/common.rs
+++ b/runtime/rust/prompty/src/renderers/common.rs
@@ -38,7 +38,7 @@ pub fn prepare_render_inputs(
 
     // Get the agent's input definitions to determine rich kinds
     if let Some(input_defs) = agent.as_inputs() {
-        for prop in &input_defs {
+        for prop in input_defs {
             if RICH_KINDS.contains(&prop.kind_str()) {
                 let nonce = generate_nonce(&prop.name);
                 if let Some(obj) = modified.as_object_mut() {
diff --git a/runtime/rust/prompty/src/tool_dispatch.rs b/runtime/rust/prompty/src/tool_dispatch.rs
index 01517cde..5a0350a4 100644
--- a/runtime/rust/prompty/src/tool_dispatch.rs
+++ b/runtime/rust/prompty/src/tool_dispatch.rs
@@ -172,11 +172,7 @@ pub fn resolve_bindings(
         return args;
     };
 
-    let Some(bindings) = tool_def.get("bindings").and_then(|b| b.as_array()) else {
-        return args;
-    };
-
-    if bindings.is_empty() {
+    if tool_def.bindings.is_empty() {
         return args;
     }
 
@@ -185,15 +181,9 @@ pub fn resolve_bindings(
         None => return args,
     };
 
-    for binding in bindings {
-        let Some(target_name) = binding.get("name").and_then(|n| n.as_str()) else {
-            continue;
-        };
-        let Some(source_input) = binding.get("input").and_then(|i| i.as_str()) else {
-            continue;
-        };
-        if let Some(value) = parent_obj.get(source_input) {
-            args_obj.insert(target_name.to_string(), value.clone());
+    for binding in &tool_def.bindings {
+        if let Some(value) = parent_obj.get(&binding.input) {
+            args_obj.insert(binding.name.clone(), value.clone());
         }
     }
 
@@ -345,11 +335,8 @@ pub async fn dispatch_tool(
 
     // Layer 3: kind handler — look up tool definition in agent.tools
     let tool_def = find_tool_def(agent, &tool_call.name);
-    if let Some(def) = &tool_def {
-        let kind = def
-            .get("kind")
-            .and_then(|k| k.as_str())
-            .unwrap_or("function");
+    if let Some(def) = tool_def {
+        let kind = def.kind_str();
 
         // Try specific kind handler, then fallback to "*" wildcard
         // Clone the Arc before dropping the read guard to avoid holding it across .await
@@ -363,7 +350,9 @@ pub async fn dispatch_tool(
                 .or_else(|| handlers.get("*").cloned())
         };
         if let Some(handler) = handler {
-            return match handler.execute_tool(def, args, agent, parent_inputs).await {
+            // Serialize the typed Tool to JSON for the trait boundary
+            let def_value = def.to_value(&crate::model::SaveContext::default());
+            return match handler.execute_tool(&def_value, args, agent, parent_inputs).await {
                 Ok(r) => r,
                 Err(e) => format!("Error: {e}"),
             };
@@ -375,15 +364,8 @@ pub async fn dispatch_tool(
 }
 
 /// Find a tool definition in `agent.tools` by name.
-fn find_tool_def(agent: &Prompty, name: &str) -> Option<serde_json::Value> {
-    let tools = agent.tools.as_array()?;
-    for tool in tools {
-        let tool_name = tool.get("name").and_then(|n| n.as_str());
-        if tool_name == Some(name) {
-            return Some(tool.clone());
-        }
-    }
-    None
+fn find_tool_def<'a>(agent: &'a Prompty, name: &str) -> Option<&'a crate::model::Tool> {
+    agent.tools.iter().find(|t| t.name == name)
 }
 
 /// Execute a user-provided tool handler (from TurnOptions.tools).
@@ -667,8 +649,12 @@ mod tests {
     }
 
     fn agent_with_tools(tools: serde_json::Value) -> Prompty {
+        use crate::model::context::LoadContext;
         let mut agent = Prompty::default();
-        agent.tools = tools;
+        if let Some(arr) = tools.as_array() {
+            let ctx = LoadContext::default();
+            agent.tools = arr.iter().map(|v| crate::model::Tool::load_from_value(v, &ctx)).collect();
+        }
         agent
     }
 
diff --git a/runtime/rust/prompty/tests/load_vectors.rs b/runtime/rust/prompty/tests/load_vectors.rs
index 439b92da..2cd8d58f 100644
--- a/runtime/rust/prompty/tests/load_vectors.rs
+++ b/runtime/rust/prompty/tests/load_vectors.rs
@@ -391,22 +391,15 @@ fn validate_tool(tool: &prompty::model::tool::Tool, expected: &Value, vec_name:
                 assert_eq!(*strict, Some(exp_strict), "[{vec_name}] tool[{idx}].strict");
             }
             if let Some(exp_params) = expected.get("parameters").and_then(Value::as_array) {
-                // Parameters may be stored as a JSON array of property objects
-                let params_arr = parameters.as_array().unwrap_or_else(|| {
-                    panic!("[{vec_name}] tool[{idx}].parameters is not an array")
-                });
                 assert_eq!(
-                    params_arr.len(),
+                    parameters.len(),
                     exp_params.len(),
                     "[{vec_name}] tool[{idx}].parameters count"
                 );
                 for (j, ep) in exp_params.iter().enumerate() {
                     if let Some(pname) = ep.get("name").and_then(Value::as_str) {
                         assert_eq!(
-                            params_arr[j]
-                                .get("name")
-                                .and_then(Value::as_str)
-                                .unwrap_or(""),
+                            parameters[j].name.as_str(),
                             pname,
                             "[{vec_name}] tool[{idx}].parameters[{j}].name"
                         );
diff --git a/runtime/rust/prompty/tests/model/anonymous_connection_test.rs b/runtime/rust/prompty/tests/model/anonymous_connection_test.rs
deleted file mode 100644
index 36f467e5..00000000
--- a/runtime/rust/prompty/tests/model/anonymous_connection_test.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::AnonymousConnection;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_anonymous_connection_load_json() {
-    let json = r####"
-{
-  "kind": "anonymous",
-  "endpoint": "https://{your-custom-endpoint}.openai.azure.com/"
-}
-"####;
-    let result = AnonymousConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "anonymous");
-    assert_eq!(instance.endpoint, "https://{your-custom-endpoint}.openai.azure.com/");
-}
-
-#[test]
-fn test_anonymous_connection_load_yaml() {
-    let yaml = r####"
-kind: anonymous
-endpoint: "https://{your-custom-endpoint}.openai.azure.com/"
-
-"####;
-    let result = AnonymousConnection::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "anonymous");
-    assert_eq!(instance.endpoint, "https://{your-custom-endpoint}.openai.azure.com/");
-}
-
-#[test]
-fn test_anonymous_connection_roundtrip() {
-    let json = r####"
-{
-  "kind": "anonymous",
-  "endpoint": "https://{your-custom-endpoint}.openai.azure.com/"
-}
-"####;
-    let result = AnonymousConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/api_key_connection_test.rs b/runtime/rust/prompty/tests/model/api_key_connection_test.rs
deleted file mode 100644
index 32bcef0b..00000000
--- a/runtime/rust/prompty/tests/model/api_key_connection_test.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::ApiKeyConnection;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_api_key_connection_load_json() {
-    let json = r####"
-{
-  "kind": "key",
-  "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",
-  "apiKey": "your-api-key"
-}
-"####;
-    let result = ApiKeyConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "key");
-    assert_eq!(instance.endpoint, "https://{your-custom-endpoint}.openai.azure.com/");
-    assert_eq!(instance.api_key, "your-api-key");
-}
-
-#[test]
-fn test_api_key_connection_load_yaml() {
-    let yaml = r####"
-kind: key
-endpoint: "https://{your-custom-endpoint}.openai.azure.com/"
-apiKey: your-api-key
-
-"####;
-    let result = ApiKeyConnection::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "key");
-    assert_eq!(instance.endpoint, "https://{your-custom-endpoint}.openai.azure.com/");
-    assert_eq!(instance.api_key, "your-api-key");
-}
-
-#[test]
-fn test_api_key_connection_roundtrip() {
-    let json = r####"
-{
-  "kind": "key",
-  "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",
-  "apiKey": "your-api-key"
-}
-"####;
-    let result = ApiKeyConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/binding_test.rs b/runtime/rust/prompty/tests/model/binding_test.rs
index 26d337d0..266409ad 100644
--- a/runtime/rust/prompty/tests/model/binding_test.rs
+++ b/runtime/rust/prompty/tests/model/binding_test.rs
@@ -13,11 +13,7 @@ fn test_binding_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = Binding::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "my-tool");
     assert_eq!(instance.input, "input-variable");
@@ -32,11 +28,7 @@ input: input-variable
 "####;
     let ctx = LoadContext::default();
     let result = Binding::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "my-tool");
     assert_eq!(instance.input, "input-variable");
@@ -56,11 +48,7 @@ fn test_binding_roundtrip() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -70,3 +58,4 @@ fn test_binding_from_string() {
     let instance = Binding::load_from_value(&value, &ctx);
     assert_eq!(instance.input, "example");
 }
+
diff --git a/runtime/rust/prompty/tests/model/compaction_complete_payload_test.rs b/runtime/rust/prompty/tests/model/compaction_complete_payload_test.rs
new file mode 100644
index 00000000..860edeb1
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/compaction_complete_payload_test.rs
@@ -0,0 +1,53 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::CompactionCompletePayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_compaction_complete_payload_load_json() {
+    let json = r####"
+{
+  "removed": 5,
+  "remaining": 3
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = CompactionCompletePayload::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.removed, 5);
+    assert_eq!(instance.remaining, 3);
+}
+
+#[test]
+fn test_compaction_complete_payload_load_yaml() {
+    let yaml = r####"
+removed: 5
+remaining: 3
+
+"####;
+    let ctx = LoadContext::default();
+    let result = CompactionCompletePayload::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.removed, 5);
+    assert_eq!(instance.remaining, 3);
+}
+
+#[test]
+fn test_compaction_complete_payload_roundtrip() {
+    let json = r####"
+{
+  "removed": 5,
+  "remaining": 3
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = CompactionCompletePayload::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/compaction_config_test.rs b/runtime/rust/prompty/tests/model/compaction_config_test.rs
new file mode 100644
index 00000000..b945d9b1
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/compaction_config_test.rs
@@ -0,0 +1,63 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::CompactionConfig;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_compaction_config_load_json() {
+    let json = r####"
+{
+  "strategy": "summarize",
+  "budget": 50000,
+  "options": {
+    "preserveSystemMessages": true
+  }
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = CompactionConfig::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert!(instance.strategy.is_some(), "Expected strategy to be Some");
+    assert_eq!(instance.strategy.as_ref().unwrap(), &"summarize");
+    assert!(instance.budget.is_some(), "Expected budget to be Some");
+    assert_eq!(instance.budget.as_ref().unwrap(), &50000);
+}
+
+#[test]
+fn test_compaction_config_load_yaml() {
+    let yaml = r####"
+strategy: summarize
+budget: 50000
+options:
+  preserveSystemMessages: true
+
+"####;
+    let ctx = LoadContext::default();
+    let result = CompactionConfig::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert!(instance.strategy.is_some(), "Expected strategy to be Some");
+    assert!(instance.budget.is_some(), "Expected budget to be Some");
+}
+
+#[test]
+fn test_compaction_config_roundtrip() {
+    let json = r####"
+{
+  "strategy": "summarize",
+  "budget": 50000,
+  "options": {
+    "preserveSystemMessages": true
+  }
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = CompactionConfig::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/compaction_failed_payload_test.rs b/runtime/rust/prompty/tests/model/compaction_failed_payload_test.rs
new file mode 100644
index 00000000..927bc77d
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/compaction_failed_payload_test.rs
@@ -0,0 +1,48 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::CompactionFailedPayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_compaction_failed_payload_load_json() {
+    let json = r####"
+{
+  "message": "Summarization prompt exceeded context window"
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = CompactionFailedPayload::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.message, "Summarization prompt exceeded context window");
+}
+
+#[test]
+fn test_compaction_failed_payload_load_yaml() {
+    let yaml = r####"
+message: Summarization prompt exceeded context window
+
+"####;
+    let ctx = LoadContext::default();
+    let result = CompactionFailedPayload::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.message, "Summarization prompt exceeded context window");
+}
+
+#[test]
+fn test_compaction_failed_payload_roundtrip() {
+    let json = r####"
+{
+  "message": "Summarization prompt exceeded context window"
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = CompactionFailedPayload::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/connection_test.rs b/runtime/rust/prompty/tests/model/connection_test.rs
index c7ea62a5..5db8f637 100644
--- a/runtime/rust/prompty/tests/model/connection_test.rs
+++ b/runtime/rust/prompty/tests/model/connection_test.rs
@@ -1,7 +1,7 @@
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
 use prompty::model::Connection;
-use prompty::model::context::LoadContext;
+use prompty::model::context::{LoadContext, SaveContext};
 
 #[test]
 fn test_connection_load_json() {
@@ -14,11 +14,7 @@ fn test_connection_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = Connection::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
 }
 
 #[test]
@@ -31,11 +27,7 @@ usageDescription: This will allow the agent to respond to an email on your behal
 "####;
     let ctx = LoadContext::default();
     let result = Connection::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
 }
 
 #[test]
@@ -51,3 +43,4 @@ fn test_connection_roundtrip() {
     let result = Connection::from_json(json, &load_ctx);
     assert!(result.is_ok(), "Failed to load: {:?}", result.err());
 }
+
diff --git a/runtime/rust/prompty/tests/model/content_part_test.rs b/runtime/rust/prompty/tests/model/content_part_test.rs
new file mode 100644
index 00000000..e1313f73
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/content_part_test.rs
@@ -0,0 +1,5 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::ContentPart;
+use prompty::model::context::{LoadContext, SaveContext};
+
diff --git a/runtime/rust/prompty/tests/model/custom_tool_test.rs b/runtime/rust/prompty/tests/model/custom_tool_test.rs
deleted file mode 100644
index 1e8cd034..00000000
--- a/runtime/rust/prompty/tests/model/custom_tool_test.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::CustomTool;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_custom_tool_load_json() {
-    let json = r####"
-{
-  "connection": {
-    "kind": "reference"
-  },
-  "options": {
-    "timeout": 30,
-    "retries": 3
-  }
-}
-"####;
-    let result = CustomTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    let _ = instance; // load succeeded, no scalar properties to validate
-}
-
-#[test]
-fn test_custom_tool_load_yaml() {
-    let yaml = r####"
-connection:
-  kind: reference
-options:
-  timeout: 30
-  retries: 3
-
-"####;
-    let result = CustomTool::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    let _ = instance; // load succeeded, no scalar properties to validate
-}
-
-#[test]
-fn test_custom_tool_roundtrip() {
-    let json = r####"
-{
-  "connection": {
-    "kind": "reference"
-  },
-  "options": {
-    "timeout": 30,
-    "retries": 3
-  }
-}
-"####;
-    let result = CustomTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/done_event_payload_test.rs b/runtime/rust/prompty/tests/model/done_event_payload_test.rs
new file mode 100644
index 00000000..a0b2e98f
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/done_event_payload_test.rs
@@ -0,0 +1,48 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::DoneEventPayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_done_event_payload_load_json() {
+    let json = r####"
+{
+  "response": "The weather in Paris is 72°F and sunny."
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = DoneEventPayload::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.response, "The weather in Paris is 72°F and sunny.");
+}
+
+#[test]
+fn test_done_event_payload_load_yaml() {
+    let yaml = r####"
+response: The weather in Paris is 72°F and sunny.
+
+"####;
+    let ctx = LoadContext::default();
+    let result = DoneEventPayload::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.response, "The weather in Paris is 72°F and sunny.");
+}
+
+#[test]
+fn test_done_event_payload_roundtrip() {
+    let json = r####"
+{
+  "response": "The weather in Paris is 72°F and sunny."
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = DoneEventPayload::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/error_event_payload_test.rs b/runtime/rust/prompty/tests/model/error_event_payload_test.rs
new file mode 100644
index 00000000..fac36069
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/error_event_payload_test.rs
@@ -0,0 +1,48 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::ErrorEventPayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_error_event_payload_load_json() {
+    let json = r####"
+{
+  "message": "Rate limit exceeded"
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = ErrorEventPayload::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.message, "Rate limit exceeded");
+}
+
+#[test]
+fn test_error_event_payload_load_yaml() {
+    let yaml = r####"
+message: Rate limit exceeded
+
+"####;
+    let ctx = LoadContext::default();
+    let result = ErrorEventPayload::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.message, "Rate limit exceeded");
+}
+
+#[test]
+fn test_error_event_payload_roundtrip() {
+    let json = r####"
+{
+  "message": "Rate limit exceeded"
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = ErrorEventPayload::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/format_config_test.rs b/runtime/rust/prompty/tests/model/format_config_test.rs
index 7010ddf9..f99f4c53 100644
--- a/runtime/rust/prompty/tests/model/format_config_test.rs
+++ b/runtime/rust/prompty/tests/model/format_config_test.rs
@@ -1,7 +1,7 @@
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
 use prompty::model::FormatConfig;
-use prompty::model::context::LoadContext;
+use prompty::model::context::{LoadContext, SaveContext};
 
 #[test]
 fn test_format_config_load_json() {
@@ -16,11 +16,7 @@ fn test_format_config_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = FormatConfig::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
 }
 
 #[test]
@@ -34,11 +30,7 @@ options:
 "####;
     let ctx = LoadContext::default();
     let result = FormatConfig::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
 }
 
 #[test]
@@ -64,3 +56,4 @@ fn test_format_config_from_format() {
     let instance = FormatConfig::load_from_value(&value, &ctx);
     let _ = instance; // abstract type, load succeeded
 }
+
diff --git a/runtime/rust/prompty/tests/model/foundry_connection_test.rs b/runtime/rust/prompty/tests/model/foundry_connection_test.rs
deleted file mode 100644
index 52d6c6aa..00000000
--- a/runtime/rust/prompty/tests/model/foundry_connection_test.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::FoundryConnection;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_foundry_connection_load_json() {
-    let json = r####"
-{
-  "kind": "foundry",
-  "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
-  "name": "my-openai-connection",
-  "connectionType": "model"
-}
-"####;
-    let result = FoundryConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "foundry");
-    assert_eq!(instance.endpoint, "https://myresource.services.ai.azure.com/api/projects/myproject");
-    assert!(instance.name.is_some(), "Expected name to be Some");
-    assert_eq!(instance.name.as_ref().unwrap(), &"my-openai-connection");
-    assert!(instance.connection_type.is_some(), "Expected connection_type to be Some");
-    assert_eq!(instance.connection_type.as_ref().unwrap(), &"model");
-}
-
-#[test]
-fn test_foundry_connection_load_yaml() {
-    let yaml = r####"
-kind: foundry
-endpoint: "https://myresource.services.ai.azure.com/api/projects/myproject"
-name: my-openai-connection
-connectionType: model
-
-"####;
-    let result = FoundryConnection::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "foundry");
-    assert_eq!(instance.endpoint, "https://myresource.services.ai.azure.com/api/projects/myproject");
-    assert!(instance.name.is_some(), "Expected name to be Some");
-    assert!(instance.connection_type.is_some(), "Expected connection_type to be Some");
-}
-
-#[test]
-fn test_foundry_connection_roundtrip() {
-    let json = r####"
-{
-  "kind": "foundry",
-  "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",
-  "name": "my-openai-connection",
-  "connectionType": "model"
-}
-"####;
-    let result = FoundryConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/function_tool_test.rs b/runtime/rust/prompty/tests/model/function_tool_test.rs
deleted file mode 100644
index 719cdf72..00000000
--- a/runtime/rust/prompty/tests/model/function_tool_test.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::FunctionTool;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_function_tool_load_json() {
-    let json = r####"
-{
-  "kind": "function",
-  "parameters": {
-    "firstName": {
-      "kind": "string",
-      "default": "Jane"
-    },
-    "lastName": {
-      "kind": "string",
-      "default": "Doe"
-    },
-    "question": {
-      "kind": "string",
-      "default": "What is the meaning of life?"
-    }
-  },
-  "strict": true
-}
-"####;
-    let result = FunctionTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "function");
-    assert!(instance.strict.is_some(), "Expected strict to be Some");
-    assert_eq!(instance.strict.as_ref().unwrap(), &true);
-}
-
-#[test]
-fn test_function_tool_load_yaml() {
-    let yaml = r####"
-kind: function
-parameters:
-  firstName:
-    kind: string
-    default: Jane
-  lastName:
-    kind: string
-    default: Doe
-  question:
-    kind: string
-    default: What is the meaning of life?
-strict: true
-
-"####;
-    let result = FunctionTool::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "function");
-    assert!(instance.strict.is_some(), "Expected strict to be Some");
-}
-
-#[test]
-fn test_function_tool_roundtrip() {
-    let json = r####"
-{
-  "kind": "function",
-  "parameters": {
-    "firstName": {
-      "kind": "string",
-      "default": "Jane"
-    },
-    "lastName": {
-      "kind": "string",
-      "default": "Doe"
-    },
-    "question": {
-      "kind": "string",
-      "default": "What is the meaning of life?"
-    }
-  },
-  "strict": true
-}
-"####;
-    let result = FunctionTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-#[test]
-fn test_function_tool_load_json_1() {
-    let json = r####"
-{
-  "kind": "function",
-  "parameters": [
-    {
-      "name": "firstName",
-      "kind": "string",
-      "default": "Jane"
-    },
-    {
-      "name": "lastName",
-      "kind": "string",
-      "default": "Doe"
-    },
-    {
-      "name": "question",
-      "kind": "string",
-      "default": "What is the meaning of life?"
-    }
-  ],
-  "strict": true
-}
-"####;
-    let result = FunctionTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "function");
-    assert!(instance.strict.is_some(), "Expected strict to be Some");
-    assert_eq!(instance.strict.as_ref().unwrap(), &true);
-}
-
-#[test]
-fn test_function_tool_load_yaml_1() {
-    let yaml = r####"
-kind: function
-parameters:
-  - name: firstName
-    kind: string
-    default: Jane
-  - name: lastName
-    kind: string
-    default: Doe
-  - name: question
-    kind: string
-    default: What is the meaning of life?
-strict: true
-
-"####;
-    let result = FunctionTool::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "function");
-    assert!(instance.strict.is_some(), "Expected strict to be Some");
-}
-
-#[test]
-fn test_function_tool_roundtrip_1() {
-    let json = r####"
-{
-  "kind": "function",
-  "parameters": [
-    {
-      "name": "firstName",
-      "kind": "string",
-      "default": "Jane"
-    },
-    {
-      "name": "lastName",
-      "kind": "string",
-      "default": "Doe"
-    },
-    {
-      "name": "question",
-      "kind": "string",
-      "default": "What is the meaning of life?"
-    }
-  ],
-  "strict": true
-}
-"####;
-    let result = FunctionTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/guardrail_result_test.rs b/runtime/rust/prompty/tests/model/guardrail_result_test.rs
new file mode 100644
index 00000000..7f000141
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/guardrail_result_test.rs
@@ -0,0 +1,74 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::GuardrailResult;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_guardrail_result_load_json() {
+    let json = r####"
+{
+  "allowed": true,
+  "reason": "Content is safe"
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = GuardrailResult::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.allowed, true);
+    assert!(instance.reason.is_some(), "Expected reason to be Some");
+    assert_eq!(instance.reason.as_ref().unwrap(), &"Content is safe");
+}
+
+#[test]
+fn test_guardrail_result_load_yaml() {
+    let yaml = r####"
+allowed: true
+reason: Content is safe
+
+"####;
+    let ctx = LoadContext::default();
+    let result = GuardrailResult::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.allowed, true);
+    assert!(instance.reason.is_some(), "Expected reason to be Some");
+}
+
+#[test]
+fn test_guardrail_result_roundtrip() {
+    let json = r####"
+{
+  "allowed": true,
+  "reason": "Content is safe"
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = GuardrailResult::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
+#[test]
+fn test_guardrail_result_factory_rewrite() {
+    let instance = GuardrailResult::rewrite(serde_json::json!("test"));
+    assert!(instance.allowed);
+    assert!(instance.rewrite.is_some());
+}
+
+#[test]
+fn test_guardrail_result_factory_deny() {
+    let instance = GuardrailResult::deny("test".to_string());
+    assert!(!instance.allowed);
+    assert!(instance.reason.is_some());
+}
+
+#[test]
+fn test_guardrail_result_factory_allow() {
+    let instance = GuardrailResult::allow();
+    assert!(instance.allowed);
+}
+
diff --git a/runtime/rust/prompty/tests/model/main.rs b/runtime/rust/prompty/tests/model/main.rs
index 5c6c4523..6af0485f 100644
--- a/runtime/rust/prompty/tests/model/main.rs
+++ b/runtime/rust/prompty/tests/model/main.rs
@@ -1,13 +1,36 @@
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
-mod binding_test;
+mod property_test;
 mod connection_test;
-mod format_config_test;
-mod mcp_approval_mode_test;
 mod model_options_test;
 mod model_test;
+mod binding_test;
+mod tool_test;
+mod mcp_approval_mode_test;
+mod format_config_test;
 mod parser_config_test;
-mod prompty_test;
-mod property_test;
 mod template_test;
-mod tool_test;
+mod prompty_test;
+mod content_part_test;
+mod message_test;
+mod tool_context_test;
+mod tool_result_test;
+mod tool_dispatch_result_test;
+mod tool_call_test;
+mod guardrail_result_test;
+mod thread_marker_test;
+mod token_usage_test;
+mod model_info_test;
+mod compaction_config_test;
+mod turn_options_test;
+mod token_event_payload_test;
+mod thinking_event_payload_test;
+mod tool_call_start_payload_test;
+mod tool_result_payload_test;
+mod status_event_payload_test;
+mod messages_updated_payload_test;
+mod done_event_payload_test;
+mod error_event_payload_test;
+mod compaction_complete_payload_test;
+mod compaction_failed_payload_test;
+mod stream_chunk_test;
diff --git a/runtime/rust/prompty/tests/model/mcp_approval_mode_test.rs b/runtime/rust/prompty/tests/model/mcp_approval_mode_test.rs
index 74d52526..2e75369c 100644
--- a/runtime/rust/prompty/tests/model/mcp_approval_mode_test.rs
+++ b/runtime/rust/prompty/tests/model/mcp_approval_mode_test.rs
@@ -18,11 +18,7 @@ fn test_mcp_approval_mode_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = McpApprovalMode::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.kind, "never");
 }
@@ -39,11 +35,7 @@ neverRequireApprovalTools:
 "####;
     let ctx = LoadContext::default();
     let result = McpApprovalMode::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.kind, "never");
 }
@@ -67,11 +59,7 @@ fn test_mcp_approval_mode_roundtrip() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -81,3 +69,4 @@ fn test_mcp_approval_mode_from_kind() {
     let instance = McpApprovalMode::load_from_value(&value, &ctx);
     assert_eq!(instance.kind, "never");
 }
+
diff --git a/runtime/rust/prompty/tests/model/mcp_tool_test.rs b/runtime/rust/prompty/tests/model/mcp_tool_test.rs
deleted file mode 100644
index cebad921..00000000
--- a/runtime/rust/prompty/tests/model/mcp_tool_test.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::McpTool;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_mcp_tool_load_json() {
-    let json = r####"
-{
-  "kind": "mcp",
-  "connection": {
-    "kind": "reference"
-  },
-  "serverName": "My MCP Server",
-  "serverDescription": "This tool allows access to MCP services.",
-  "approvalMode": {
-    "kind": "always"
-  },
-  "allowedTools": [
-    "operation1",
-    "operation2"
-  ]
-}
-"####;
-    let result = McpTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "mcp");
-    assert_eq!(instance.server_name, "My MCP Server");
-    assert!(instance.server_description.is_some(), "Expected server_description to be Some");
-    assert_eq!(instance.server_description.as_ref().unwrap(), &"This tool allows access to MCP services.");
-}
-
-#[test]
-fn test_mcp_tool_load_yaml() {
-    let yaml = r####"
-kind: mcp
-connection:
-  kind: reference
-serverName: My MCP Server
-serverDescription: This tool allows access to MCP services.
-approvalMode:
-  kind: always
-allowedTools:
-  - operation1
-  - operation2
-
-"####;
-    let result = McpTool::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "mcp");
-    assert_eq!(instance.server_name, "My MCP Server");
-    assert!(instance.server_description.is_some(), "Expected server_description to be Some");
-}
-
-#[test]
-fn test_mcp_tool_roundtrip() {
-    let json = r####"
-{
-  "kind": "mcp",
-  "connection": {
-    "kind": "reference"
-  },
-  "serverName": "My MCP Server",
-  "serverDescription": "This tool allows access to MCP services.",
-  "approvalMode": {
-    "kind": "always"
-  },
-  "allowedTools": [
-    "operation1",
-    "operation2"
-  ]
-}
-"####;
-    let result = McpTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/message_test.rs b/runtime/rust/prompty/tests/model/message_test.rs
new file mode 100644
index 00000000..0fc78866
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/message_test.rs
@@ -0,0 +1,86 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::Message;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_message_load_json() {
+    let json = r####"
+{
+  "role": "user",
+  "parts": [
+    {
+      "kind": "text",
+      "value": "Hello!"
+    }
+  ],
+  "metadata": {
+    "source": "user-input"
+  }
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = Message::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.role, "user");
+}
+
+#[test]
+fn test_message_load_yaml() {
+    let yaml = r####"
+role: user
+parts:
+  - kind: text
+    value: Hello!
+metadata:
+  source: user-input
+
+"####;
+    let ctx = LoadContext::default();
+    let result = Message::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.role, "user");
+}
+
+#[test]
+fn test_message_roundtrip() {
+    let json = r####"
+{
+  "role": "user",
+  "parts": [
+    {
+      "kind": "text",
+      "value": "Hello!"
+    }
+  ],
+  "metadata": {
+    "source": "user-input"
+  }
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = Message::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
+#[test]
+fn test_message_factory_assistant() {
+    let instance = Message::assistant("test".to_string());
+}
+
+#[test]
+fn test_message_factory_system() {
+    let instance = Message::system("test".to_string());
+}
+
+#[test]
+fn test_message_factory_user() {
+    let instance = Message::user("test".to_string());
+}
+
diff --git a/runtime/rust/prompty/tests/model/messages_updated_payload_test.rs b/runtime/rust/prompty/tests/model/messages_updated_payload_test.rs
new file mode 100644
index 00000000..fa4be158
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/messages_updated_payload_test.rs
@@ -0,0 +1,5 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::MessagesUpdatedPayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
diff --git a/runtime/rust/prompty/tests/model/model_info_test.rs b/runtime/rust/prompty/tests/model/model_info_test.rs
new file mode 100644
index 00000000..b2e1125a
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/model_info_test.rs
@@ -0,0 +1,93 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::ModelInfo;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_model_info_load_json() {
+    let json = r####"
+{
+  "id": "gpt-4o",
+  "displayName": "GPT-4o",
+  "ownedBy": "openai",
+  "contextWindow": 128000,
+  "inputModalities": [
+    "text",
+    "image"
+  ],
+  "outputModalities": [
+    "text"
+  ],
+  "additionalProperties": {
+    "supportsStreaming": true
+  }
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = ModelInfo::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.id, "gpt-4o");
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert_eq!(instance.display_name.as_ref().unwrap(), &"GPT-4o");
+    assert!(instance.owned_by.is_some(), "Expected owned_by to be Some");
+    assert_eq!(instance.owned_by.as_ref().unwrap(), &"openai");
+    assert!(instance.context_window.is_some(), "Expected context_window to be Some");
+    assert_eq!(instance.context_window.as_ref().unwrap(), &128000);
+}
+
+#[test]
+fn test_model_info_load_yaml() {
+    let yaml = r####"
+id: gpt-4o
+displayName: GPT-4o
+ownedBy: openai
+contextWindow: 128000
+inputModalities:
+  - text
+  - image
+outputModalities:
+  - text
+additionalProperties:
+  supportsStreaming: true
+
+"####;
+    let ctx = LoadContext::default();
+    let result = ModelInfo::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.id, "gpt-4o");
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert!(instance.owned_by.is_some(), "Expected owned_by to be Some");
+    assert!(instance.context_window.is_some(), "Expected context_window to be Some");
+}
+
+#[test]
+fn test_model_info_roundtrip() {
+    let json = r####"
+{
+  "id": "gpt-4o",
+  "displayName": "GPT-4o",
+  "ownedBy": "openai",
+  "contextWindow": 128000,
+  "inputModalities": [
+    "text",
+    "image"
+  ],
+  "outputModalities": [
+    "text"
+  ],
+  "additionalProperties": {
+    "supportsStreaming": true
+  }
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = ModelInfo::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/model_options_test.rs b/runtime/rust/prompty/tests/model/model_options_test.rs
index 5746225c..52e8228b 100644
--- a/runtime/rust/prompty/tests/model/model_options_test.rs
+++ b/runtime/rust/prompty/tests/model/model_options_test.rs
@@ -27,42 +27,23 @@ fn test_model_options_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = ModelOptions::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
-    assert!(
-        instance.frequency_penalty.is_some(),
-        "Expected frequency_penalty to be Some"
-    );
+    assert!(instance.frequency_penalty.is_some(), "Expected frequency_penalty to be Some");
     assert_eq!(instance.frequency_penalty.as_ref().unwrap(), &0.5);
-    assert!(
-        instance.max_output_tokens.is_some(),
-        "Expected max_output_tokens to be Some"
-    );
+    assert!(instance.max_output_tokens.is_some(), "Expected max_output_tokens to be Some");
     assert_eq!(instance.max_output_tokens.as_ref().unwrap(), &2048);
-    assert!(
-        instance.presence_penalty.is_some(),
-        "Expected presence_penalty to be Some"
-    );
+    assert!(instance.presence_penalty.is_some(), "Expected presence_penalty to be Some");
     assert_eq!(instance.presence_penalty.as_ref().unwrap(), &0.3);
     assert!(instance.seed.is_some(), "Expected seed to be Some");
     assert_eq!(instance.seed.as_ref().unwrap(), &42);
-    assert!(
-        instance.temperature.is_some(),
-        "Expected temperature to be Some"
-    );
+    assert!(instance.temperature.is_some(), "Expected temperature to be Some");
     assert_eq!(instance.temperature.as_ref().unwrap(), &0.7);
     assert!(instance.top_k.is_some(), "Expected top_k to be Some");
     assert_eq!(instance.top_k.as_ref().unwrap(), &40);
     assert!(instance.top_p.is_some(), "Expected top_p to be Some");
     assert_eq!(instance.top_p.as_ref().unwrap(), &0.9);
-    assert!(
-        instance.allow_multiple_tool_calls.is_some(),
-        "Expected allow_multiple_tool_calls to be Some"
-    );
+    assert!(instance.allow_multiple_tool_calls.is_some(), "Expected allow_multiple_tool_calls to be Some");
     assert_eq!(instance.allow_multiple_tool_calls.as_ref().unwrap(), &true);
 }
 
@@ -87,35 +68,16 @@ additionalProperties:
 "####;
     let ctx = LoadContext::default();
     let result = ModelOptions::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
-    assert!(
-        instance.frequency_penalty.is_some(),
-        "Expected frequency_penalty to be Some"
-    );
-    assert!(
-        instance.max_output_tokens.is_some(),
-        "Expected max_output_tokens to be Some"
-    );
-    assert!(
-        instance.presence_penalty.is_some(),
-        "Expected presence_penalty to be Some"
-    );
+    assert!(instance.frequency_penalty.is_some(), "Expected frequency_penalty to be Some");
+    assert!(instance.max_output_tokens.is_some(), "Expected max_output_tokens to be Some");
+    assert!(instance.presence_penalty.is_some(), "Expected presence_penalty to be Some");
     assert!(instance.seed.is_some(), "Expected seed to be Some");
-    assert!(
-        instance.temperature.is_some(),
-        "Expected temperature to be Some"
-    );
+    assert!(instance.temperature.is_some(), "Expected temperature to be Some");
     assert!(instance.top_k.is_some(), "Expected top_k to be Some");
     assert!(instance.top_p.is_some(), "Expected top_p to be Some");
-    assert!(
-        instance.allow_multiple_tool_calls.is_some(),
-        "Expected allow_multiple_tool_calls to be Some"
-    );
+    assert!(instance.allow_multiple_tool_calls.is_some(), "Expected allow_multiple_tool_calls to be Some");
 }
 
 #[test]
@@ -146,9 +108,6 @@ fn test_model_options_roundtrip() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
+
diff --git a/runtime/rust/prompty/tests/model/model_test.rs b/runtime/rust/prompty/tests/model/model_test.rs
index b9359f9b..e39df689 100644
--- a/runtime/rust/prompty/tests/model/model_test.rs
+++ b/runtime/rust/prompty/tests/model/model_test.rs
@@ -24,11 +24,7 @@ fn test_model_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = Model::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.id, "gpt-35-turbo");
     assert!(instance.provider.is_some(), "Expected provider to be Some");
@@ -55,11 +51,7 @@ options:
 "####;
     let ctx = LoadContext::default();
     let result = Model::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.id, "gpt-35-turbo");
     assert!(instance.provider.is_some(), "Expected provider to be Some");
@@ -91,11 +83,7 @@ fn test_model_roundtrip() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -105,3 +93,4 @@ fn test_model_from_model() {
     let instance = Model::load_from_value(&value, &ctx);
     assert_eq!(instance.id, "example");
 }
+
diff --git a/runtime/rust/prompty/tests/model/o_auth_connection_test.rs b/runtime/rust/prompty/tests/model/o_auth_connection_test.rs
deleted file mode 100644
index 1e33675f..00000000
--- a/runtime/rust/prompty/tests/model/o_auth_connection_test.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::OAuthConnection;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_o_auth_connection_load_json() {
-    let json = r####"
-{
-  "kind": "oauth",
-  "endpoint": "https://api.example.com",
-  "clientId": "your-client-id",
-  "clientSecret": "your-client-secret",
-  "tokenUrl": "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token",
-  "scopes": [
-    "https://cognitiveservices.azure.com/.default"
-  ]
-}
-"####;
-    let result = OAuthConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "oauth");
-    assert_eq!(instance.endpoint, "https://api.example.com");
-    assert_eq!(instance.client_id, "your-client-id");
-    assert_eq!(instance.client_secret, "your-client-secret");
-    assert_eq!(instance.token_url, "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token");
-}
-
-#[test]
-fn test_o_auth_connection_load_yaml() {
-    let yaml = r####"
-kind: oauth
-endpoint: "https://api.example.com"
-clientId: your-client-id
-clientSecret: your-client-secret
-tokenUrl: "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
-scopes:
-  - "https://cognitiveservices.azure.com/.default"
-
-"####;
-    let result = OAuthConnection::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "oauth");
-    assert_eq!(instance.endpoint, "https://api.example.com");
-    assert_eq!(instance.client_id, "your-client-id");
-    assert_eq!(instance.client_secret, "your-client-secret");
-    assert_eq!(instance.token_url, "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token");
-}
-
-#[test]
-fn test_o_auth_connection_roundtrip() {
-    let json = r####"
-{
-  "kind": "oauth",
-  "endpoint": "https://api.example.com",
-  "clientId": "your-client-id",
-  "clientSecret": "your-client-secret",
-  "tokenUrl": "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token",
-  "scopes": [
-    "https://cognitiveservices.azure.com/.default"
-  ]
-}
-"####;
-    let result = OAuthConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/open_api_tool_test.rs b/runtime/rust/prompty/tests/model/open_api_tool_test.rs
deleted file mode 100644
index 2a91ce33..00000000
--- a/runtime/rust/prompty/tests/model/open_api_tool_test.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::OpenApiTool;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_open_api_tool_load_json() {
-    let json = r####"
-{
-  "kind": "openapi",
-  "connection": {
-    "kind": "reference"
-  },
-  "specification": "./openapi.json"
-}
-"####;
-    let result = OpenApiTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "openapi");
-    assert_eq!(instance.specification, "./openapi.json");
-}
-
-#[test]
-fn test_open_api_tool_load_yaml() {
-    let yaml = r####"
-kind: openapi
-connection:
-  kind: reference
-specification: ./openapi.json
-
-"####;
-    let result = OpenApiTool::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "openapi");
-    assert_eq!(instance.specification, "./openapi.json");
-}
-
-#[test]
-fn test_open_api_tool_roundtrip() {
-    let json = r####"
-{
-  "kind": "openapi",
-  "connection": {
-    "kind": "reference"
-  },
-  "specification": "./openapi.json"
-}
-"####;
-    let result = OpenApiTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/parser_config_test.rs b/runtime/rust/prompty/tests/model/parser_config_test.rs
index a5a151e0..294f718d 100644
--- a/runtime/rust/prompty/tests/model/parser_config_test.rs
+++ b/runtime/rust/prompty/tests/model/parser_config_test.rs
@@ -1,7 +1,7 @@
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
 use prompty::model::ParserConfig;
-use prompty::model::context::LoadContext;
+use prompty::model::context::{LoadContext, SaveContext};
 
 #[test]
 fn test_parser_config_load_json() {
@@ -15,11 +15,7 @@ fn test_parser_config_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = ParserConfig::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
 }
 
 #[test]
@@ -32,11 +28,7 @@ options:
 "####;
     let ctx = LoadContext::default();
     let result = ParserConfig::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
 }
 
 #[test]
@@ -61,3 +53,4 @@ fn test_parser_config_from_parser() {
     let instance = ParserConfig::load_from_value(&value, &ctx);
     let _ = instance; // abstract type, load succeeded
 }
+
diff --git a/runtime/rust/prompty/tests/model/prompty_test.rs b/runtime/rust/prompty/tests/model/prompty_test.rs
index ac64b7ef..63603a31 100644
--- a/runtime/rust/prompty/tests/model/prompty_test.rs
+++ b/runtime/rust/prompty/tests/model/prompty_test.rs
@@ -74,34 +74,15 @@ fn test_prompty_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
     assert_eq!(instance.display_name.as_ref().unwrap(), &"Basic Prompt");
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert_eq!(
-        instance.description.as_ref().unwrap(),
-        &"A basic prompt that uses the GPT-3 chat API to answer questions"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
-    assert_eq!(
-        instance.instructions.as_ref().unwrap(),
-        &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}"
-    );
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert_eq!(instance.description.as_ref().unwrap(), &"A basic prompt that uses the GPT-3 chat API to answer questions");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
+    assert_eq!(instance.instructions.as_ref().unwrap(), &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
 }
 
 #[test]
@@ -175,25 +156,12 @@ instructions: "system:
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
 }
 
 #[test]
@@ -271,11 +239,7 @@ fn test_prompty_roundtrip() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -348,34 +312,15 @@ fn test_prompty_load_json_1() {
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
     assert_eq!(instance.display_name.as_ref().unwrap(), &"Basic Prompt");
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert_eq!(
-        instance.description.as_ref().unwrap(),
-        &"A basic prompt that uses the GPT-3 chat API to answer questions"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
-    assert_eq!(
-        instance.instructions.as_ref().unwrap(),
-        &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}"
-    );
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert_eq!(instance.description.as_ref().unwrap(), &"A basic prompt that uses the GPT-3 chat API to answer questions");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
+    assert_eq!(instance.instructions.as_ref().unwrap(), &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
 }
 
 #[test]
@@ -449,25 +394,12 @@ instructions: "system:
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
 }
 
 #[test]
@@ -544,11 +476,7 @@ fn test_prompty_roundtrip_1() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -623,34 +551,15 @@ fn test_prompty_load_json_2() {
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
     assert_eq!(instance.display_name.as_ref().unwrap(), &"Basic Prompt");
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert_eq!(
-        instance.description.as_ref().unwrap(),
-        &"A basic prompt that uses the GPT-3 chat API to answer questions"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
-    assert_eq!(
-        instance.instructions.as_ref().unwrap(),
-        &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}"
-    );
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert_eq!(instance.description.as_ref().unwrap(), &"A basic prompt that uses the GPT-3 chat API to answer questions");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
+    assert_eq!(instance.instructions.as_ref().unwrap(), &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
 }
 
 #[test]
@@ -724,25 +633,12 @@ instructions: "system:
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
 }
 
 #[test]
@@ -821,11 +717,7 @@ fn test_prompty_roundtrip_2() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -899,34 +791,15 @@ fn test_prompty_load_json_3() {
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
     assert_eq!(instance.display_name.as_ref().unwrap(), &"Basic Prompt");
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert_eq!(
-        instance.description.as_ref().unwrap(),
-        &"A basic prompt that uses the GPT-3 chat API to answer questions"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
-    assert_eq!(
-        instance.instructions.as_ref().unwrap(),
-        &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}"
-    );
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert_eq!(instance.description.as_ref().unwrap(), &"A basic prompt that uses the GPT-3 chat API to answer questions");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
+    assert_eq!(instance.instructions.as_ref().unwrap(), &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
 }
 
 #[test]
@@ -1000,25 +873,12 @@ instructions: "system:
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
 }
 
 #[test]
@@ -1096,11 +956,7 @@ fn test_prompty_roundtrip_3() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -1177,34 +1033,15 @@ fn test_prompty_load_json_4() {
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
     assert_eq!(instance.display_name.as_ref().unwrap(), &"Basic Prompt");
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert_eq!(
-        instance.description.as_ref().unwrap(),
-        &"A basic prompt that uses the GPT-3 chat API to answer questions"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
-    assert_eq!(
-        instance.instructions.as_ref().unwrap(),
-        &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}"
-    );
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert_eq!(instance.description.as_ref().unwrap(), &"A basic prompt that uses the GPT-3 chat API to answer questions");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
+    assert_eq!(instance.instructions.as_ref().unwrap(), &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
 }
 
 #[test]
@@ -1278,25 +1115,12 @@ instructions: "system:
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
 }
 
 #[test]
@@ -1377,11 +1201,7 @@ fn test_prompty_roundtrip_4() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -1457,34 +1277,15 @@ fn test_prompty_load_json_5() {
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
     assert_eq!(instance.display_name.as_ref().unwrap(), &"Basic Prompt");
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert_eq!(
-        instance.description.as_ref().unwrap(),
-        &"A basic prompt that uses the GPT-3 chat API to answer questions"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
-    assert_eq!(
-        instance.instructions.as_ref().unwrap(),
-        &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}"
-    );
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert_eq!(instance.description.as_ref().unwrap(), &"A basic prompt that uses the GPT-3 chat API to answer questions");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
+    assert_eq!(instance.instructions.as_ref().unwrap(), &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
 }
 
 #[test]
@@ -1558,25 +1359,12 @@ instructions: "system:
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
 }
 
 #[test]
@@ -1656,11 +1444,7 @@ fn test_prompty_roundtrip_5() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -1738,34 +1522,15 @@ fn test_prompty_load_json_6() {
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
     assert_eq!(instance.display_name.as_ref().unwrap(), &"Basic Prompt");
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert_eq!(
-        instance.description.as_ref().unwrap(),
-        &"A basic prompt that uses the GPT-3 chat API to answer questions"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
-    assert_eq!(
-        instance.instructions.as_ref().unwrap(),
-        &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}"
-    );
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert_eq!(instance.description.as_ref().unwrap(), &"A basic prompt that uses the GPT-3 chat API to answer questions");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
+    assert_eq!(instance.instructions.as_ref().unwrap(), &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
 }
 
 #[test]
@@ -1839,25 +1604,12 @@ instructions: "system:
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
 }
 
 #[test]
@@ -1939,11 +1691,7 @@ fn test_prompty_roundtrip_6() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
 #[test]
@@ -2020,34 +1768,15 @@ fn test_prompty_load_json_7() {
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
     assert_eq!(instance.display_name.as_ref().unwrap(), &"Basic Prompt");
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert_eq!(
-        instance.description.as_ref().unwrap(),
-        &"A basic prompt that uses the GPT-3 chat API to answer questions"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
-    assert_eq!(
-        instance.instructions.as_ref().unwrap(),
-        &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}"
-    );
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert_eq!(instance.description.as_ref().unwrap(), &"A basic prompt that uses the GPT-3 chat API to answer questions");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
+    assert_eq!(instance.instructions.as_ref().unwrap(), &"system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
 }
 
 #[test]
@@ -2121,25 +1850,12 @@ instructions: "system:
 "####;
     let ctx = LoadContext::default();
     let result = Prompty::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     assert_eq!(instance.name, "basic-prompt");
-    assert!(
-        instance.display_name.is_some(),
-        "Expected display_name to be Some"
-    );
-    assert!(
-        instance.description.is_some(),
-        "Expected description to be Some"
-    );
-    assert!(
-        instance.instructions.is_some(),
-        "Expected instructions to be Some"
-    );
+    assert!(instance.display_name.is_some(), "Expected display_name to be Some");
+    assert!(instance.description.is_some(), "Expected description to be Some");
+    assert!(instance.instructions.is_some(), "Expected instructions to be Some");
 }
 
 #[test]
@@ -2220,9 +1936,6 @@ fn test_prompty_roundtrip_7() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
+
diff --git a/runtime/rust/prompty/tests/model/prompty_tool_test.rs b/runtime/rust/prompty/tests/model/prompty_tool_test.rs
deleted file mode 100644
index 1aaf858f..00000000
--- a/runtime/rust/prompty/tests/model/prompty_tool_test.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::PromptyTool;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_prompty_tool_load_json() {
-    let json = r####"
-{
-  "kind": "prompty",
-  "path": "./summarize.prompty",
-  "mode": "single"
-}
-"####;
-    let result = PromptyTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "prompty");
-    assert_eq!(instance.path, "./summarize.prompty");
-    assert_eq!(instance.mode, "single");
-}
-
-#[test]
-fn test_prompty_tool_load_yaml() {
-    let yaml = r####"
-kind: prompty
-path: ./summarize.prompty
-mode: single
-
-"####;
-    let result = PromptyTool::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "prompty");
-    assert_eq!(instance.path, "./summarize.prompty");
-    assert_eq!(instance.mode, "single");
-}
-
-#[test]
-fn test_prompty_tool_roundtrip() {
-    let json = r####"
-{
-  "kind": "prompty",
-  "path": "./summarize.prompty",
-  "mode": "single"
-}
-"####;
-    let result = PromptyTool::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/property_test.rs b/runtime/rust/prompty/tests/model/property_test.rs
index 7ba02fb6..623c3692 100644
--- a/runtime/rust/prompty/tests/model/property_test.rs
+++ b/runtime/rust/prompty/tests/model/property_test.rs
@@ -1,7 +1,7 @@
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
 use prompty::model::Property;
-use prompty::model::context::LoadContext;
+use prompty::model::context::{LoadContext, SaveContext};
 
 #[test]
 fn test_property_load_json() {
@@ -22,11 +22,7 @@ fn test_property_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = Property::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
 }
 
 #[test]
@@ -46,11 +42,7 @@ enumValues:
 "####;
     let ctx = LoadContext::default();
     let result = Property::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
 }
 
 #[test]
@@ -106,3 +98,4 @@ fn test_property_from_input_4() {
     let instance = Property::load_from_value(&value, &ctx);
     let _ = instance; // abstract type, load succeeded
 }
+
diff --git a/runtime/rust/prompty/tests/model/reference_connection_test.rs b/runtime/rust/prompty/tests/model/reference_connection_test.rs
deleted file mode 100644
index f2a550dd..00000000
--- a/runtime/rust/prompty/tests/model/reference_connection_test.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::ReferenceConnection;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_reference_connection_load_json() {
-    let json = r####"
-{
-  "kind": "reference",
-  "name": "my-reference-connection",
-  "target": "my-target-resource"
-}
-"####;
-    let result = ReferenceConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "reference");
-    assert_eq!(instance.name, "my-reference-connection");
-    assert!(instance.target.is_some(), "Expected target to be Some");
-    assert_eq!(instance.target.as_ref().unwrap(), &"my-target-resource");
-}
-
-#[test]
-fn test_reference_connection_load_yaml() {
-    let yaml = r####"
-kind: reference
-name: my-reference-connection
-target: my-target-resource
-
-"####;
-    let result = ReferenceConnection::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "reference");
-    assert_eq!(instance.name, "my-reference-connection");
-    assert!(instance.target.is_some(), "Expected target to be Some");
-}
-
-#[test]
-fn test_reference_connection_roundtrip() {
-    let json = r####"
-{
-  "kind": "reference",
-  "name": "my-reference-connection",
-  "target": "my-target-resource"
-}
-"####;
-    let result = ReferenceConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/remote_connection_test.rs b/runtime/rust/prompty/tests/model/remote_connection_test.rs
deleted file mode 100644
index a102bb6d..00000000
--- a/runtime/rust/prompty/tests/model/remote_connection_test.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use prompty::model::RemoteConnection;
-use prompty::model::context::{LoadContext, SaveContext};
-
-
-#[test]
-fn test_remote_connection_load_json() {
-    let json = r####"
-{
-  "kind": "remote",
-  "name": "my-reference-connection",
-  "endpoint": "https://{your-custom-endpoint}.openai.azure.com/"
-}
-"####;
-    let result = RemoteConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "remote");
-    assert_eq!(instance.name, "my-reference-connection");
-    assert_eq!(instance.endpoint, "https://{your-custom-endpoint}.openai.azure.com/");
-}
-
-#[test]
-fn test_remote_connection_load_yaml() {
-    let yaml = r####"
-kind: remote
-name: my-reference-connection
-endpoint: "https://{your-custom-endpoint}.openai.azure.com/"
-
-"####;
-    let result = RemoteConnection::from_yaml(yaml, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    let instance = result.unwrap();
-    assert_eq!(instance.kind, "remote");
-    assert_eq!(instance.name, "my-reference-connection");
-    assert_eq!(instance.endpoint, "https://{your-custom-endpoint}.openai.azure.com/");
-}
-
-#[test]
-fn test_remote_connection_roundtrip() {
-    let json = r####"
-{
-  "kind": "remote",
-  "name": "my-reference-connection",
-  "endpoint": "https://{your-custom-endpoint}.openai.azure.com/"
-}
-"####;
-    let result = RemoteConnection::from_json(json, &LoadContext::default());
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-}
-
-
-
diff --git a/runtime/rust/prompty/tests/model/status_event_payload_test.rs b/runtime/rust/prompty/tests/model/status_event_payload_test.rs
new file mode 100644
index 00000000..ccea16df
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/status_event_payload_test.rs
@@ -0,0 +1,48 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::StatusEventPayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_status_event_payload_load_json() {
+    let json = r####"
+{
+  "message": "Starting iteration 3"
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = StatusEventPayload::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.message, "Starting iteration 3");
+}
+
+#[test]
+fn test_status_event_payload_load_yaml() {
+    let yaml = r####"
+message: Starting iteration 3
+
+"####;
+    let ctx = LoadContext::default();
+    let result = StatusEventPayload::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.message, "Starting iteration 3");
+}
+
+#[test]
+fn test_status_event_payload_roundtrip() {
+    let json = r####"
+{
+  "message": "Starting iteration 3"
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = StatusEventPayload::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/stream_chunk_test.rs b/runtime/rust/prompty/tests/model/stream_chunk_test.rs
new file mode 100644
index 00000000..27545daf
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/stream_chunk_test.rs
@@ -0,0 +1,5 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::StreamChunk;
+use prompty::model::context::{LoadContext, SaveContext};
+
diff --git a/runtime/rust/prompty/tests/model/template_test.rs b/runtime/rust/prompty/tests/model/template_test.rs
index d3e65627..f1de9810 100644
--- a/runtime/rust/prompty/tests/model/template_test.rs
+++ b/runtime/rust/prompty/tests/model/template_test.rs
@@ -17,11 +17,7 @@ fn test_template_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = Template::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     let _ = instance; // load succeeded, no scalar properties to validate
 }
@@ -37,11 +33,7 @@ parser:
 "####;
     let ctx = LoadContext::default();
     let result = Template::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     let _ = instance; // load succeeded, no scalar properties to validate
 }
@@ -64,9 +56,6 @@ fn test_template_roundtrip() {
     let instance = result.unwrap();
     let save_ctx = SaveContext::default();
     let json_output = instance.to_json(&save_ctx);
-    assert!(
-        json_output.is_ok(),
-        "Failed to serialize to JSON: {:?}",
-        json_output.err()
-    );
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
+
diff --git a/runtime/rust/prompty/tests/model/thinking_event_payload_test.rs b/runtime/rust/prompty/tests/model/thinking_event_payload_test.rs
new file mode 100644
index 00000000..7bdba2f4
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/thinking_event_payload_test.rs
@@ -0,0 +1,48 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::ThinkingEventPayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_thinking_event_payload_load_json() {
+    let json = r####"
+{
+  "token": "Let me consider..."
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = ThinkingEventPayload::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.token, "Let me consider...");
+}
+
+#[test]
+fn test_thinking_event_payload_load_yaml() {
+    let yaml = r####"
+token: Let me consider...
+
+"####;
+    let ctx = LoadContext::default();
+    let result = ThinkingEventPayload::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.token, "Let me consider...");
+}
+
+#[test]
+fn test_thinking_event_payload_roundtrip() {
+    let json = r####"
+{
+  "token": "Let me consider..."
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = ThinkingEventPayload::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/thread_marker_test.rs b/runtime/rust/prompty/tests/model/thread_marker_test.rs
new file mode 100644
index 00000000..b099d1ab
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/thread_marker_test.rs
@@ -0,0 +1,53 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::ThreadMarker;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_thread_marker_load_json() {
+    let json = r####"
+{
+  "name": "thread",
+  "kind": "thread"
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = ThreadMarker::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.name, "thread");
+    assert_eq!(instance.kind, "thread");
+}
+
+#[test]
+fn test_thread_marker_load_yaml() {
+    let yaml = r####"
+name: thread
+kind: thread
+
+"####;
+    let ctx = LoadContext::default();
+    let result = ThreadMarker::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.name, "thread");
+    assert_eq!(instance.kind, "thread");
+}
+
+#[test]
+fn test_thread_marker_roundtrip() {
+    let json = r####"
+{
+  "name": "thread",
+  "kind": "thread"
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = ThreadMarker::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/token_event_payload_test.rs b/runtime/rust/prompty/tests/model/token_event_payload_test.rs
new file mode 100644
index 00000000..b30573c3
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/token_event_payload_test.rs
@@ -0,0 +1,48 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::TokenEventPayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_token_event_payload_load_json() {
+    let json = r####"
+{
+  "token": "Hello"
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = TokenEventPayload::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.token, "Hello");
+}
+
+#[test]
+fn test_token_event_payload_load_yaml() {
+    let yaml = r####"
+token: Hello
+
+"####;
+    let ctx = LoadContext::default();
+    let result = TokenEventPayload::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.token, "Hello");
+}
+
+#[test]
+fn test_token_event_payload_roundtrip() {
+    let json = r####"
+{
+  "token": "Hello"
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = TokenEventPayload::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/token_usage_test.rs b/runtime/rust/prompty/tests/model/token_usage_test.rs
new file mode 100644
index 00000000..c5b85474
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/token_usage_test.rs
@@ -0,0 +1,61 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::TokenUsage;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_token_usage_load_json() {
+    let json = r####"
+{
+  "promptTokens": 150,
+  "completionTokens": 42,
+  "totalTokens": 192
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = TokenUsage::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert!(instance.prompt_tokens.is_some(), "Expected prompt_tokens to be Some");
+    assert_eq!(instance.prompt_tokens.as_ref().unwrap(), &150);
+    assert!(instance.completion_tokens.is_some(), "Expected completion_tokens to be Some");
+    assert_eq!(instance.completion_tokens.as_ref().unwrap(), &42);
+    assert!(instance.total_tokens.is_some(), "Expected total_tokens to be Some");
+    assert_eq!(instance.total_tokens.as_ref().unwrap(), &192);
+}
+
+#[test]
+fn test_token_usage_load_yaml() {
+    let yaml = r####"
+promptTokens: 150
+completionTokens: 42
+totalTokens: 192
+
+"####;
+    let ctx = LoadContext::default();
+    let result = TokenUsage::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert!(instance.prompt_tokens.is_some(), "Expected prompt_tokens to be Some");
+    assert!(instance.completion_tokens.is_some(), "Expected completion_tokens to be Some");
+    assert!(instance.total_tokens.is_some(), "Expected total_tokens to be Some");
+}
+
+#[test]
+fn test_token_usage_roundtrip() {
+    let json = r####"
+{
+  "promptTokens": 150,
+  "completionTokens": 42,
+  "totalTokens": 192
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = TokenUsage::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/tool_call_start_payload_test.rs b/runtime/rust/prompty/tests/model/tool_call_start_payload_test.rs
new file mode 100644
index 00000000..88e236ec
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/tool_call_start_payload_test.rs
@@ -0,0 +1,53 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::ToolCallStartPayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_tool_call_start_payload_load_json() {
+    let json = r####"
+{
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = ToolCallStartPayload::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.name, "get_weather");
+    assert_eq!(instance.arguments, "{\"city\": \"Paris\"}");
+}
+
+#[test]
+fn test_tool_call_start_payload_load_yaml() {
+    let yaml = r####"
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+"####;
+    let ctx = LoadContext::default();
+    let result = ToolCallStartPayload::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.name, "get_weather");
+    assert_eq!(instance.arguments, "{\"city\": \"Paris\"}");
+}
+
+#[test]
+fn test_tool_call_start_payload_roundtrip() {
+    let json = r####"
+{
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = ToolCallStartPayload::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/tool_call_test.rs b/runtime/rust/prompty/tests/model/tool_call_test.rs
new file mode 100644
index 00000000..f6e41c5a
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/tool_call_test.rs
@@ -0,0 +1,58 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::ToolCall;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_tool_call_load_json() {
+    let json = r####"
+{
+  "id": "call_abc123",
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = ToolCall::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.id, "call_abc123");
+    assert_eq!(instance.name, "get_weather");
+    assert_eq!(instance.arguments, "{\"city\": \"Paris\"}");
+}
+
+#[test]
+fn test_tool_call_load_yaml() {
+    let yaml = r####"
+id: call_abc123
+name: get_weather
+arguments: "{\"city\": \"Paris\"}"
+
+"####;
+    let ctx = LoadContext::default();
+    let result = ToolCall::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.id, "call_abc123");
+    assert_eq!(instance.name, "get_weather");
+    assert_eq!(instance.arguments, "{\"city\": \"Paris\"}");
+}
+
+#[test]
+fn test_tool_call_roundtrip() {
+    let json = r####"
+{
+  "id": "call_abc123",
+  "name": "get_weather",
+  "arguments": "{\"city\": \"Paris\"}"
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = ToolCall::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/array_property_test.rs b/runtime/rust/prompty/tests/model/tool_context_test.rs
similarity index 56%
rename from runtime/rust/prompty/tests/model/array_property_test.rs
rename to runtime/rust/prompty/tests/model/tool_context_test.rs
index 83216223..3df17482 100644
--- a/runtime/rust/prompty/tests/model/array_property_test.rs
+++ b/runtime/rust/prompty/tests/model/tool_context_test.rs
@@ -1,53 +1,53 @@
-
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
-use prompty::model::ArrayProperty;
+use prompty::model::ToolContext;
 use prompty::model::context::{LoadContext, SaveContext};
 
-
 #[test]
-fn test_array_property_load_json() {
+fn test_tool_context_load_json() {
     let json = r####"
 {
-  "items": {
-    "kind": "string"
+  "metadata": {
+    "userId": "user-123"
   }
 }
 "####;
-    let result = ArrayProperty::from_json(json, &LoadContext::default());
+    let ctx = LoadContext::default();
+    let result = ToolContext::from_json(json, &ctx);
     assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     let _ = instance; // load succeeded, no scalar properties to validate
 }
 
 #[test]
-fn test_array_property_load_yaml() {
+fn test_tool_context_load_yaml() {
     let yaml = r####"
-items:
-  kind: string
+metadata:
+  userId: user-123
 
 "####;
-    let result = ArrayProperty::from_yaml(yaml, &LoadContext::default());
+    let ctx = LoadContext::default();
+    let result = ToolContext::from_yaml(yaml, &ctx);
     assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     let _ = instance; // load succeeded, no scalar properties to validate
 }
 
 #[test]
-fn test_array_property_roundtrip() {
+fn test_tool_context_roundtrip() {
     let json = r####"
 {
-  "items": {
-    "kind": "string"
+  "metadata": {
+    "userId": "user-123"
   }
 }
 "####;
-    let result = ArrayProperty::from_json(json, &LoadContext::default());
+    let load_ctx = LoadContext::default();
+    let result = ToolContext::from_json(json, &load_ctx);
     assert!(result.is_ok(), "Failed to load: {:?}", result.err());
     let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
     assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
-
-
diff --git a/runtime/rust/prompty/tests/model/tool_dispatch_result_test.rs b/runtime/rust/prompty/tests/model/tool_dispatch_result_test.rs
new file mode 100644
index 00000000..c93e9ce5
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/tool_dispatch_result_test.rs
@@ -0,0 +1,73 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::ToolDispatchResult;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_tool_dispatch_result_load_json() {
+    let json = r####"
+{
+  "toolCallId": "call_abc123",
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = ToolDispatchResult::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.tool_call_id, "call_abc123");
+    assert_eq!(instance.name, "get_weather");
+}
+
+#[test]
+fn test_tool_dispatch_result_load_yaml() {
+    let yaml = r####"
+toolCallId: call_abc123
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+"####;
+    let ctx = LoadContext::default();
+    let result = ToolDispatchResult::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.tool_call_id, "call_abc123");
+    assert_eq!(instance.name, "get_weather");
+}
+
+#[test]
+fn test_tool_dispatch_result_roundtrip() {
+    let json = r####"
+{
+  "toolCallId": "call_abc123",
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = ToolDispatchResult::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/tool_result_payload_test.rs b/runtime/rust/prompty/tests/model/tool_result_payload_test.rs
new file mode 100644
index 00000000..b8e23897
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/tool_result_payload_test.rs
@@ -0,0 +1,68 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::ToolResultPayload;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_tool_result_payload_load_json() {
+    let json = r####"
+{
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = ToolResultPayload::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.name, "get_weather");
+}
+
+#[test]
+fn test_tool_result_payload_load_yaml() {
+    let yaml = r####"
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+
+"####;
+    let ctx = LoadContext::default();
+    let result = ToolResultPayload::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert_eq!(instance.name, "get_weather");
+}
+
+#[test]
+fn test_tool_result_payload_roundtrip() {
+    let json = r####"
+{
+  "name": "get_weather",
+  "result": {
+    "parts": [
+      {
+        "kind": "text",
+        "value": "72°F and sunny"
+      }
+    ]
+  }
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = ToolResultPayload::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/rust/prompty/tests/model/object_property_test.rs b/runtime/rust/prompty/tests/model/tool_result_test.rs
similarity index 50%
rename from runtime/rust/prompty/tests/model/object_property_test.rs
rename to runtime/rust/prompty/tests/model/tool_result_test.rs
index a39fa743..f2e0d23d 100644
--- a/runtime/rust/prompty/tests/model/object_property_test.rs
+++ b/runtime/rust/prompty/tests/model/tool_result_test.rs
@@ -1,66 +1,65 @@
-
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
-use prompty::model::ObjectProperty;
+use prompty::model::ToolResult;
 use prompty::model::context::{LoadContext, SaveContext};
 
-
 #[test]
-fn test_object_property_load_json() {
+fn test_tool_result_load_json() {
     let json = r####"
 {
-  "properties": {
-    "property1": {
-      "kind": "string"
-    },
-    "property2": {
-      "kind": "number"
+  "parts": [
+    {
+      "kind": "text",
+      "value": "72°F and sunny"
     }
-  }
+  ]
 }
 "####;
-    let result = ObjectProperty::from_json(json, &LoadContext::default());
+    let ctx = LoadContext::default();
+    let result = ToolResult::from_json(json, &ctx);
     assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
     let instance = result.unwrap();
     let _ = instance; // load succeeded, no scalar properties to validate
 }
 
 #[test]
-fn test_object_property_load_yaml() {
+fn test_tool_result_load_yaml() {
     let yaml = r####"
-properties:
-  property1:
-    kind: string
-  property2:
-    kind: number
+parts:
+  - kind: text
+    value: 72°F and sunny
 
 "####;
-    let result = ObjectProperty::from_yaml(yaml, &LoadContext::default());
+    let ctx = LoadContext::default();
+    let result = ToolResult::from_yaml(yaml, &ctx);
     assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
     let instance = result.unwrap();
     let _ = instance; // load succeeded, no scalar properties to validate
 }
 
 #[test]
-fn test_object_property_roundtrip() {
+fn test_tool_result_roundtrip() {
     let json = r####"
 {
-  "properties": {
-    "property1": {
-      "kind": "string"
-    },
-    "property2": {
-      "kind": "number"
+  "parts": [
+    {
+      "kind": "text",
+      "value": "72°F and sunny"
     }
-  }
+  ]
 }
 "####;
-    let result = ObjectProperty::from_json(json, &LoadContext::default());
+    let load_ctx = LoadContext::default();
+    let result = ToolResult::from_json(json, &load_ctx);
     assert!(result.is_ok(), "Failed to load: {:?}", result.err());
     let instance = result.unwrap();
-    let json_output = instance.to_json(&SaveContext::default());
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
     assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
 }
 
-
+#[test]
+fn test_tool_result_factory_text() {
+    let instance = ToolResult::text("test".to_string());
+}
 
diff --git a/runtime/rust/prompty/tests/model/tool_test.rs b/runtime/rust/prompty/tests/model/tool_test.rs
index 14ddd1e9..f161a382 100644
--- a/runtime/rust/prompty/tests/model/tool_test.rs
+++ b/runtime/rust/prompty/tests/model/tool_test.rs
@@ -1,7 +1,7 @@
 // Code generated by AgentSchema emitter; DO NOT EDIT.
 
 use prompty::model::Tool;
-use prompty::model::context::LoadContext;
+use prompty::model::context::{LoadContext, SaveContext};
 
 #[test]
 fn test_tool_load_json() {
@@ -17,11 +17,7 @@ fn test_tool_load_json() {
 "####;
     let ctx = LoadContext::default();
     let result = Tool::from_json(json, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from JSON: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
 }
 
 #[test]
@@ -36,11 +32,7 @@ bindings:
 "####;
     let ctx = LoadContext::default();
     let result = Tool::from_yaml(yaml, &ctx);
-    assert!(
-        result.is_ok(),
-        "Failed to load from YAML: {:?}",
-        result.err()
-    );
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
 }
 
 #[test]
@@ -59,3 +51,4 @@ fn test_tool_roundtrip() {
     let result = Tool::from_json(json, &load_ctx);
     assert!(result.is_ok(), "Failed to load: {:?}", result.err());
 }
+
diff --git a/runtime/rust/prompty/tests/model/turn_options_test.rs b/runtime/rust/prompty/tests/model/turn_options_test.rs
new file mode 100644
index 00000000..f9180f39
--- /dev/null
+++ b/runtime/rust/prompty/tests/model/turn_options_test.rs
@@ -0,0 +1,87 @@
+// Code generated by AgentSchema emitter; DO NOT EDIT.
+
+use prompty::model::TurnOptions;
+use prompty::model::context::{LoadContext, SaveContext};
+
+#[test]
+fn test_turn_options_load_json() {
+    let json = r####"
+{
+  "maxIterations": 10,
+  "maxLlmRetries": 3,
+  "contextBudget": 100000,
+  "parallelToolCalls": true,
+  "raw": false,
+  "turn": 1,
+  "compaction": {
+    "strategy": "summarize"
+  }
+}
+"####;
+    let ctx = LoadContext::default();
+    let result = TurnOptions::from_json(json, &ctx);
+    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
+    let instance = result.unwrap();
+    assert!(instance.max_iterations.is_some(), "Expected max_iterations to be Some");
+    assert_eq!(instance.max_iterations.as_ref().unwrap(), &10);
+    assert!(instance.max_llm_retries.is_some(), "Expected max_llm_retries to be Some");
+    assert_eq!(instance.max_llm_retries.as_ref().unwrap(), &3);
+    assert!(instance.context_budget.is_some(), "Expected context_budget to be Some");
+    assert_eq!(instance.context_budget.as_ref().unwrap(), &100000);
+    assert!(instance.parallel_tool_calls.is_some(), "Expected parallel_tool_calls to be Some");
+    assert_eq!(instance.parallel_tool_calls.as_ref().unwrap(), &true);
+    assert!(instance.raw.is_some(), "Expected raw to be Some");
+    assert_eq!(instance.raw.as_ref().unwrap(), &false);
+    assert!(instance.turn.is_some(), "Expected turn to be Some");
+    assert_eq!(instance.turn.as_ref().unwrap(), &1);
+}
+
+#[test]
+fn test_turn_options_load_yaml() {
+    let yaml = r####"
+maxIterations: 10
+maxLlmRetries: 3
+contextBudget: 100000
+parallelToolCalls: true
+raw: false
+turn: 1
+compaction:
+  strategy: summarize
+
+"####;
+    let ctx = LoadContext::default();
+    let result = TurnOptions::from_yaml(yaml, &ctx);
+    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
+    let instance = result.unwrap();
+    assert!(instance.max_iterations.is_some(), "Expected max_iterations to be Some");
+    assert!(instance.max_llm_retries.is_some(), "Expected max_llm_retries to be Some");
+    assert!(instance.context_budget.is_some(), "Expected context_budget to be Some");
+    assert!(instance.parallel_tool_calls.is_some(), "Expected parallel_tool_calls to be Some");
+    assert!(instance.raw.is_some(), "Expected raw to be Some");
+    assert!(instance.turn.is_some(), "Expected turn to be Some");
+}
+
+#[test]
+fn test_turn_options_roundtrip() {
+    let json = r####"
+{
+  "maxIterations": 10,
+  "maxLlmRetries": 3,
+  "contextBudget": 100000,
+  "parallelToolCalls": true,
+  "raw": false,
+  "turn": 1,
+  "compaction": {
+    "strategy": "summarize"
+  }
+}
+"####;
+    let load_ctx = LoadContext::default();
+    let result = TurnOptions::from_json(json, &load_ctx);
+    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
+    let instance = result.unwrap();
+    let save_ctx = SaveContext::default();
+    let json_output = instance.to_json(&save_ctx);
+    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
+}
+
diff --git a/runtime/typescript/package-lock.json b/runtime/typescript/package-lock.json
index fd9672d4..dc98ecbc 100644
--- a/runtime/typescript/package-lock.json
+++ b/runtime/typescript/package-lock.json
@@ -3498,11 +3498,11 @@
     },
     "packages/anthropic": {
       "name": "@prompty/anthropic",
-      "version": "2.0.0-alpha.8",
+      "version": "2.0.0-alpha.10",
       "license": "MIT",
       "devDependencies": {
         "@anthropic-ai/sdk": "^0.39.0",
-        "@prompty/core": "file:../core",
+        "@prompty/core": "^2.0.0-alpha.10",
         "@types/node": "^20.11.0",
         "dotenv": "^16.4.0",
         "tsup": "^8.4.0",
@@ -3514,7 +3514,7 @@
       },
       "peerDependencies": {
         "@anthropic-ai/sdk": ">=0.39.0",
-        "@prompty/core": "^2.0.0-alpha.8"
+        "@prompty/core": "^2.0.0-alpha.10"
       },
       "peerDependenciesMeta": {
         "@anthropic-ai/sdk": {
@@ -3524,7 +3524,7 @@
     },
     "packages/core": {
       "name": "@prompty/core",
-      "version": "2.0.0-alpha.8",
+      "version": "2.0.0-alpha.10",
       "license": "MIT",
       "dependencies": {
         "gray-matter": "^4.0.3",
@@ -3534,8 +3534,8 @@
       },
       "devDependencies": {
         "@opentelemetry/api": "^1.9.0",
-        "@prompty/anthropic": "*",
-        "@prompty/openai": "*",
+        "@prompty/anthropic": "^2.0.0-alpha.10",
+        "@prompty/openai": "^2.0.0-alpha.10",
         "@types/mustache": "^4.2.5",
         "@types/node": "^20.11.0",
         "@types/nunjucks": "^3.2.6",
@@ -3558,7 +3558,7 @@
     },
     "packages/foundry": {
       "name": "@prompty/foundry",
-      "version": "2.0.0-alpha.8",
+      "version": "2.0.0-alpha.10",
       "license": "MIT",
       "dependencies": {
         "@azure/ai-projects": "^2.0.1",
@@ -3566,8 +3566,8 @@
         "openai": "^4.80.0"
       },
       "devDependencies": {
-        "@prompty/core": "^2.0.0-alpha.8",
-        "@prompty/openai": "^2.0.0-alpha.8",
+        "@prompty/core": "^2.0.0-alpha.10",
+        "@prompty/openai": "^2.0.0-alpha.10",
         "@types/node": "^20.11.0",
         "dotenv": "^16.4.0",
         "tsup": "^8.4.0",
@@ -3578,19 +3578,19 @@
         "node": ">=18.0.0"
       },
       "peerDependencies": {
-        "@prompty/core": "^2.0.0-alpha.8",
-        "@prompty/openai": "^2.0.0-alpha.8"
+        "@prompty/core": "^2.0.0-alpha.10",
+        "@prompty/openai": "^2.0.0-alpha.10"
       }
     },
     "packages/openai": {
       "name": "@prompty/openai",
-      "version": "2.0.0-alpha.8",
+      "version": "2.0.0-alpha.10",
       "license": "MIT",
       "dependencies": {
         "openai": "^4.80.0"
       },
       "devDependencies": {
-        "@prompty/core": "^2.0.0-alpha.8",
+        "@prompty/core": "^2.0.0-alpha.10",
         "@types/node": "^20.11.0",
         "dotenv": "^16.4.0",
         "tsup": "^8.4.0",
@@ -3601,7 +3601,7 @@
         "node": ">=18.0.0"
       },
       "peerDependencies": {
-        "@prompty/core": "^2.0.0-alpha.8"
+        "@prompty/core": "^2.0.0-alpha.10"
       }
     }
   }
diff --git a/runtime/typescript/packages/anthropic/src/wire.ts b/runtime/typescript/packages/anthropic/src/wire.ts
index f6038da7..8bf06b23 100644
--- a/runtime/typescript/packages/anthropic/src/wire.ts
+++ b/runtime/typescript/packages/anthropic/src/wire.ts
@@ -80,7 +80,10 @@ function partToWire(part: ContentPart): Record<string, unknown> {
       if (part.source.startsWith("data:")) {
         // Data URL — extract base64 payload and MIME type
         const [header, data] = part.source.split(",", 2);
-        const mediaType = header?.match(/data:(.*?);/)?.[1] ?? "image/png";
+        // Extract MIME type between "data:" and ";" without regex backtracking
+        const mimeStart = header?.indexOf("data:") === 0 ? 5 : 0;
+        const mimeEnd = header?.indexOf(";", mimeStart) ?? -1;
+        const mediaType = mimeEnd > mimeStart ? header!.slice(mimeStart, mimeEnd) : "image/png";
         return {
           type: "image",
           source: {
@@ -130,13 +133,19 @@ export function buildChatArgs(
     }
   }
 
+  const opts = buildOptions(agent);
+
   const args: Record<string, unknown> = {
     model,
     messages: conversationMessages,
-    max_tokens: agent.model?.options?.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
-    ...buildOptions(agent),
+    ...opts,
   };
 
+  // Anthropic requires max_tokens — use default if toWire didn't emit it
+  if (!("max_tokens" in args)) {
+    args.max_tokens = DEFAULT_MAX_TOKENS;
+  }
+
   // System prompt as separate parameter
   if (systemParts.length > 0) {
     args.system = systemParts.join("\n\n");
@@ -176,12 +185,7 @@ function buildOptions(agent: Prompty): Record<string, unknown> {
   const opts = agent.model?.options;
   if (!opts) return {};
 
-  const result: Record<string, unknown> = {};
-
-  if (opts.temperature !== undefined) result.temperature = opts.temperature;
-  if (opts.topP !== undefined) result.top_p = opts.topP;
-  if (opts.topK !== undefined) result.top_k = opts.topK;
-  if (opts.stopSequences !== undefined) result.stop_sequences = opts.stopSequences;
+  const result = opts.toWire("anthropic");
 
   // Pass through additionalProperties — but don't overwrite mapped keys
   if (opts.additionalProperties) {
diff --git a/runtime/typescript/packages/anthropic/tests/e2e.test.ts b/runtime/typescript/packages/anthropic/tests/e2e.test.ts
index dd5c17c9..0f526aba 100644
--- a/runtime/typescript/packages/anthropic/tests/e2e.test.ts
+++ b/runtime/typescript/packages/anthropic/tests/e2e.test.ts
@@ -24,6 +24,7 @@ import { buildChatArgs, messageToWire, toolsToWire, outputSchemaToWire } from ".
 import { registerExecutor, registerProcessor } from "@prompty/core";
 import { Message } from "@prompty/core";
 import type { TextPart } from "@prompty/core";
+import { ModelOptions } from "@prompty/core";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -127,7 +128,7 @@ describe("wire format", () => {
 
     // buildChatArgs needs a Prompty-like agent
     const mockAgent = {
-      model: { id: "claude-sonnet-4-5-20250929", options: { maxOutputTokens: 512 } },
+      model: { id: "claude-sonnet-4-5-20250929", options: new ModelOptions({ maxOutputTokens: 512 }) },
       tools: [],
       outputs: [],
     };
@@ -150,13 +151,13 @@ describe("wire format", () => {
       {
         model: {
           id: "claude-haiku-4-5-20250929",
-          options: {
+          options: new ModelOptions({
             temperature: 0.5,
             topP: 0.9,
             topK: 40,
             maxOutputTokens: 2000,
             stopSequences: ["END"],
-          },
+          }),
         },
       } as any,
       msgs,
diff --git a/runtime/typescript/packages/core/src/core/types.ts b/runtime/typescript/packages/core/src/core/types.ts
index e49fca01..a622dd8d 100644
--- a/runtime/typescript/packages/core/src/core/types.ts
+++ b/runtime/typescript/packages/core/src/core/types.ts
@@ -1,13 +1,21 @@
 /**
- * Core message types for the Prompty pipeline.
+ * Runtime extensions for the canonical {@link Message} type.
  *
- * These types are protocol-agnostic — they represent the abstract
- * message format that executors translate to provider-specific
- * wire formats (e.g., OpenAI JSON).
+ * The generated model at ``../model/message`` defines the canonical data shape
+ * and a {@link MessageHelpers} contract that declares ``text`` (getter) and
+ * ``toTextContent()``. This module keeps a positional-constructor convenience
+ * class for now, but wires it up to ``implements MessageHelpers`` so the
+ * TypeScript compiler enforces the generated contract.
+ *
+ * TODO (E1/B2 follow-up): migrate call sites from ``new Message(role, parts)``
+ * to ``new Message({ role, parts })`` and delete this wrapper class, leaving
+ * only the generated class as the canonical type.
  *
  * @module
  */
 
+import type { MessageHelpers } from "../model/message";
+
 // ---------------------------------------------------------------------------
 // Content Parts (discriminated union by `kind`)
 // ---------------------------------------------------------------------------
@@ -60,8 +68,13 @@ export type Role = "system" | "user" | "assistant" | "developer" | "tool";
  *
  * Executors convert this to provider-specific wire format.
  * Parsers produce this from rendered template text.
+ *
+ * Implements {@link MessageHelpers} — the contract generated from the
+ * TypeSpec ``@method`` stubs on ``Message``. The TypeScript compiler verifies
+ * that ``text`` and ``toTextContent`` stay in sync with the generated
+ * interface.
  */
-export class Message {
+export class Message implements MessageHelpers {
   role: Role;
   parts: ContentPart[];
   metadata: Record<string, unknown>;
diff --git a/runtime/typescript/packages/core/src/model/binding.ts b/runtime/typescript/packages/core/src/model/binding.ts
index 0a0065f1..09af6323 100644
--- a/runtime/typescript/packages/core/src/model/binding.ts
+++ b/runtime/typescript/packages/core/src/model/binding.ts
@@ -3,62 +3,39 @@
 
 import { LoadContext, SaveContext } from "./context";
 
-/**
- * Represents a binding between an input property and a tool parameter.
- *
- */
 export class Binding {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = "input";
 
-  /**
-   * Name of the binding
-   */
   name: string = "";
-
-  /**
-   * The input property that will be bound to the tool parameter argument
-   */
   input: string = "";
 
-  /**
-   * Initializes a new instance of Binding.
-   */
   constructor(init?: Partial<Binding>) {
     this.name = init?.name ?? "";
-
     this.input = init?.input ?? "";
   }
 
   //#region Load Methods
 
-  /**
-   * Load a Binding instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Binding instance.
-   */
   static load(data: Record<string, unknown>, context?: LoadContext): Binding {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
     // Handle alternate representations
     if (typeof data === "string") {
-      data = { input: data };
-    } else if (typeof data === "number") {
-    } else if (typeof data === "boolean") {
+      const instance = new Binding();
+      instance.input = data as string;
+      if (context) {
+        return context.processOutput(instance) as Binding;
+      }
+      return instance;
     }
 
-    // Create new instance
     const instance = new Binding();
 
     if (data["name"] !== undefined && data["name"] !== null) {
       instance.name = String(data["name"]);
     }
-
     if (data["input"] !== undefined && data["input"] !== null) {
       instance.input = String(data["input"]);
     }
@@ -73,20 +50,17 @@ export class Binding {
 
   //#region Save Methods
 
-  /**
-   * Save the Binding instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as Binding) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.name !== undefined && obj.name !== null) {
       result["name"] = obj.name;
     }
-
     if (obj.input !== undefined && obj.input !== null) {
       result["input"] = obj.input;
     }
@@ -94,85 +68,30 @@ export class Binding {
     if (context) {
       return context.processDict(result);
     }
-
     return result;
   }
 
-  /**
-   * Convert the Binding instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the Binding instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a Binding instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Binding instance.
-   */
   static fromJson(json: string, context?: LoadContext): Binding {
     const data = JSON.parse(json);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return Binding.load({ input: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return Binding.load({ input: data }, context);
-    }
-
     return Binding.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a Binding instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Binding instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): Binding {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return Binding.load({ input: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return Binding.load({ input: data }, context);
-    }
-
     return Binding.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/compaction-complete-payload.ts b/runtime/typescript/packages/core/src/model/compaction-complete-payload.ts
new file mode 100644
index 00000000..c60deb5b
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/compaction-complete-payload.ts
@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class CompactionCompletePayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  removed: number = 0;
+  remaining: number = 0;
+
+  constructor(init?: Partial<CompactionCompletePayload>) {
+    this.removed = init?.removed ?? 0;
+    this.remaining = init?.remaining ?? 0;
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): CompactionCompletePayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new CompactionCompletePayload();
+
+    if (data["removed"] !== undefined && data["removed"] !== null) {
+      instance.removed = Number(data["removed"]);
+    }
+    if (data["remaining"] !== undefined && data["remaining"] !== null) {
+      instance.remaining = Number(data["remaining"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as CompactionCompletePayload;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.removed !== undefined && obj.removed !== null) {
+      result["removed"] = obj.removed;
+    }
+    if (obj.remaining !== undefined && obj.remaining !== null) {
+      result["remaining"] = obj.remaining;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): CompactionCompletePayload {
+    const data = JSON.parse(json);
+    return CompactionCompletePayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): CompactionCompletePayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return CompactionCompletePayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/compaction-config.ts b/runtime/typescript/packages/core/src/model/compaction-config.ts
new file mode 100644
index 00000000..c41de579
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/compaction-config.ts
@@ -0,0 +1,101 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class CompactionConfig {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  strategy?: string | undefined;
+  budget?: number | undefined;
+  options?: Record<string, unknown> | undefined;
+
+  constructor(init?: Partial<CompactionConfig>) {
+    if (init?.strategy !== undefined) {
+      this.strategy = init.strategy;
+    }
+    if (init?.budget !== undefined) {
+      this.budget = init.budget;
+    }
+    if (init?.options !== undefined) {
+      this.options = init.options;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): CompactionConfig {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new CompactionConfig();
+
+    if (data["strategy"] !== undefined && data["strategy"] !== null) {
+      instance.strategy = String(data["strategy"]);
+    }
+    if (data["budget"] !== undefined && data["budget"] !== null) {
+      instance.budget = Number(data["budget"]);
+    }
+    if (data["options"] !== undefined && data["options"] !== null) {
+      instance.options = data["options"] as Record<string, unknown>;
+    }
+
+    if (context) {
+      return context.processOutput(instance) as CompactionConfig;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.strategy !== undefined && obj.strategy !== null) {
+      result["strategy"] = obj.strategy;
+    }
+    if (obj.budget !== undefined && obj.budget !== null) {
+      result["budget"] = obj.budget;
+    }
+    if (obj.options !== undefined && obj.options !== null) {
+      result["options"] = obj.options;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): CompactionConfig {
+    const data = JSON.parse(json);
+    return CompactionConfig.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): CompactionConfig {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return CompactionConfig.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/compaction-failed-payload.ts b/runtime/typescript/packages/core/src/model/compaction-failed-payload.ts
new file mode 100644
index 00000000..8e286d52
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/compaction-failed-payload.ts
@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class CompactionFailedPayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  message: string = "";
+
+  constructor(init?: Partial<CompactionFailedPayload>) {
+    this.message = init?.message ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): CompactionFailedPayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new CompactionFailedPayload();
+
+    if (data["message"] !== undefined && data["message"] !== null) {
+      instance.message = String(data["message"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as CompactionFailedPayload;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.message !== undefined && obj.message !== null) {
+      result["message"] = obj.message;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): CompactionFailedPayload {
+    const data = JSON.parse(json);
+    return CompactionFailedPayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): CompactionFailedPayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return CompactionFailedPayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/connection.ts b/runtime/typescript/packages/core/src/model/connection.ts
index 80d6102b..a3f7c854 100644
--- a/runtime/typescript/packages/core/src/model/connection.ts
+++ b/runtime/typescript/packages/core/src/model/connection.ts
@@ -3,43 +3,18 @@
 
 import { LoadContext, SaveContext } from "./context";
 
-/**
- * Connection configuration for AI agents.
- * `provider`, `kind`, and `endpoint` are required properties here,
- * but this section can accept additional via options.
- *
- */
 export abstract class Connection {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens)
-   */
   kind: string = "";
-
-  /**
-   * The authority level for the connection, indicating under whose authority the connection is made (e.g., 'user', 'agent', 'system')
-   */
   authenticationMode?: string | undefined;
-
-  /**
-   * The usage description for the connection, providing context on how this connection will be used
-   */
   usageDescription?: string | undefined;
 
-  /**
-   * Initializes a new instance of Connection.
-   */
   constructor(init?: Partial<Connection>) {
     this.kind = init?.kind ?? "";
-
     if (init?.authenticationMode !== undefined) {
       this.authenticationMode = init.authenticationMode;
     }
-
     if (init?.usageDescription !== undefined) {
       this.usageDescription = init.usageDescription;
     }
@@ -47,18 +22,9 @@ export abstract class Connection {
 
   //#region Load Methods
 
-  /**
-   * Load a Connection instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Connection instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): Connection {
+  static load(data: Record<string, unknown>, context?: LoadContext): Connection {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
     // Load polymorphic Connection instance
@@ -67,18 +33,10 @@ export abstract class Connection {
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
-    if (
-      data["authenticationMode"] !== undefined &&
-      data["authenticationMode"] !== null
-    ) {
+    if (data["authenticationMode"] !== undefined && data["authenticationMode"] !== null) {
       instance.authenticationMode = String(data["authenticationMode"]);
     }
-
-    if (
-      data["usageDescription"] !== undefined &&
-      data["usageDescription"] !== null
-    ) {
+    if (data["usageDescription"] !== undefined && data["usageDescription"] !== null) {
       instance.usageDescription = String(data["usageDescription"]);
     }
 
@@ -88,16 +46,7 @@ export abstract class Connection {
     return instance;
   }
 
-  /**
-   * Load polymorphic Connection based on discriminator.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Connection instance.
-   */
-  private static loadKind(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): Connection {
+  private static loadKind(data: Record<string, unknown>, context?: LoadContext): Connection {
     const discriminatorValue = data["kind"];
     if (discriminatorValue !== undefined && discriminatorValue !== null) {
       const discriminator = String(discriminatorValue).toLowerCase();
@@ -110,17 +59,14 @@ export abstract class Connection {
           return ApiKeyConnection.load(data, context);
         case "anonymous":
           return AnonymousConnection.load(data, context);
-        case "foundry":
-          return FoundryConnection.load(data, context);
         case "oauth":
           return OAuthConnection.load(data, context);
+        case "foundry":
+          return FoundryConnection.load(data, context);
         default:
-          throw new Error(
-            `Unknown Connection discriminator value: ${discriminator}`,
-          );
+          throw new Error(`Unknown Connection discriminator value: ${discriminator}`);
       }
     }
-
     throw new Error("Missing Connection discriminator property: 'kind'");
   }
 
@@ -128,27 +74,20 @@ export abstract class Connection {
 
   //#region Save Methods
 
-  /**
-   * Save the Connection instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as Connection) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
-    if (
-      obj.authenticationMode !== undefined &&
-      obj.authenticationMode !== null
-    ) {
+    if (obj.authenticationMode !== undefined && obj.authenticationMode !== null) {
       result["authenticationMode"] = obj.authenticationMode;
     }
-
     if (obj.usageDescription !== undefined && obj.usageDescription !== null) {
       result["usageDescription"] = obj.usageDescription;
     }
@@ -156,94 +95,44 @@ export abstract class Connection {
     if (context) {
       return context.processDict(result);
     }
-
     return result;
   }
 
-  /**
-   * Convert the Connection instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the Connection instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a Connection instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Connection instance.
-   */
   static fromJson(json: string, context?: LoadContext): Connection {
     const data = JSON.parse(json);
-
     return Connection.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a Connection instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Connection instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): Connection {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return Connection.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * Connection configuration for AI services using named connections.
- *
- */
 export class ReferenceConnection extends Connection {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens)
-   */
   kind: string = "reference";
-
-  /**
-   * The name of the connection
-   */
   name: string = "";
-
-  /**
-   * The target resource or service that this connection refers to
-   */
   target?: string | undefined;
 
-  /**
-   * Initializes a new instance of ReferenceConnection.
-   */
   constructor(init?: Partial<ReferenceConnection>) {
     super(init);
-
     this.kind = init?.kind ?? "reference";
-
     this.name = init?.name ?? "";
-
     if (init?.target !== undefined) {
       this.target = init.target;
     }
@@ -251,31 +140,19 @@ export class ReferenceConnection extends Connection {
 
   //#region Load Methods
 
-  /**
-   * Load a ReferenceConnection instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ReferenceConnection instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): ReferenceConnection {
+  static load(data: Record<string, unknown>, context?: LoadContext): ReferenceConnection {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new ReferenceConnection();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["name"] !== undefined && data["name"] !== null) {
       instance.name = String(data["name"]);
     }
-
     if (data["target"] !== undefined && data["target"] !== null) {
       instance.target = String(data["target"]);
     }
@@ -290,15 +167,11 @@ export class ReferenceConnection extends Connection {
 
   //#region Save Methods
 
-  /**
-   * Save the ReferenceConnection instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context
-      ? (context.processObject(this) as ReferenceConnection)
-      : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -306,132 +179,68 @@ export class ReferenceConnection extends Connection {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.name !== undefined && obj.name !== null) {
       result["name"] = obj.name;
     }
-
     if (obj.target !== undefined && obj.target !== null) {
       result["target"] = obj.target;
     }
-
     return result;
   }
 
-  /**
-   * Convert the ReferenceConnection instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the ReferenceConnection instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a ReferenceConnection instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ReferenceConnection instance.
-   */
   static fromJson(json: string, context?: LoadContext): ReferenceConnection {
     const data = JSON.parse(json);
-
     return ReferenceConnection.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a ReferenceConnection instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ReferenceConnection instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): ReferenceConnection {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return ReferenceConnection.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * Connection configuration for AI services using named connections.
- *
- */
 export class RemoteConnection extends Connection {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens)
-   */
   kind: string = "remote";
-
-  /**
-   * The name of the connection
-   */
   name: string = "";
-
-  /**
-   * The endpoint URL for the AI service
-   */
   endpoint: string = "";
 
-  /**
-   * Initializes a new instance of RemoteConnection.
-   */
   constructor(init?: Partial<RemoteConnection>) {
     super(init);
-
     this.kind = init?.kind ?? "remote";
-
     this.name = init?.name ?? "";
-
     this.endpoint = init?.endpoint ?? "";
   }
 
   //#region Load Methods
 
-  /**
-   * Load a RemoteConnection instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded RemoteConnection instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): RemoteConnection {
+  static load(data: Record<string, unknown>, context?: LoadContext): RemoteConnection {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new RemoteConnection();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["name"] !== undefined && data["name"] !== null) {
       instance.name = String(data["name"]);
     }
-
     if (data["endpoint"] !== undefined && data["endpoint"] !== null) {
       instance.endpoint = String(data["endpoint"]);
     }
@@ -446,15 +255,11 @@ export class RemoteConnection extends Connection {
 
   //#region Save Methods
 
-  /**
-   * Save the RemoteConnection instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context
-      ? (context.processObject(this) as RemoteConnection)
-      : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -462,132 +267,68 @@ export class RemoteConnection extends Connection {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.name !== undefined && obj.name !== null) {
       result["name"] = obj.name;
     }
-
     if (obj.endpoint !== undefined && obj.endpoint !== null) {
       result["endpoint"] = obj.endpoint;
     }
-
     return result;
   }
 
-  /**
-   * Convert the RemoteConnection instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the RemoteConnection instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a RemoteConnection instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded RemoteConnection instance.
-   */
   static fromJson(json: string, context?: LoadContext): RemoteConnection {
     const data = JSON.parse(json);
-
     return RemoteConnection.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a RemoteConnection instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded RemoteConnection instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): RemoteConnection {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return RemoteConnection.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * Connection configuration for AI services using API keys.
- *
- */
 export class ApiKeyConnection extends Connection {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens)
-   */
   kind: string = "key";
-
-  /**
-   * The endpoint URL for the AI service
-   */
   endpoint: string = "";
-
-  /**
-   * The API key for authenticating with the AI service
-   */
   apiKey: string = "";
 
-  /**
-   * Initializes a new instance of ApiKeyConnection.
-   */
   constructor(init?: Partial<ApiKeyConnection>) {
     super(init);
-
     this.kind = init?.kind ?? "key";
-
     this.endpoint = init?.endpoint ?? "";
-
     this.apiKey = init?.apiKey ?? "";
   }
 
   //#region Load Methods
 
-  /**
-   * Load a ApiKeyConnection instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ApiKeyConnection instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): ApiKeyConnection {
+  static load(data: Record<string, unknown>, context?: LoadContext): ApiKeyConnection {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new ApiKeyConnection();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["endpoint"] !== undefined && data["endpoint"] !== null) {
       instance.endpoint = String(data["endpoint"]);
     }
-
     if (data["apiKey"] !== undefined && data["apiKey"] !== null) {
       instance.apiKey = String(data["apiKey"]);
     }
@@ -602,15 +343,11 @@ export class ApiKeyConnection extends Connection {
 
   //#region Save Methods
 
-  /**
-   * Save the ApiKeyConnection instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context
-      ? (context.processObject(this) as ApiKeyConnection)
-      : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -618,121 +355,63 @@ export class ApiKeyConnection extends Connection {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.endpoint !== undefined && obj.endpoint !== null) {
       result["endpoint"] = obj.endpoint;
     }
-
     if (obj.apiKey !== undefined && obj.apiKey !== null) {
       result["apiKey"] = obj.apiKey;
     }
-
     return result;
   }
 
-  /**
-   * Convert the ApiKeyConnection instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the ApiKeyConnection instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a ApiKeyConnection instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ApiKeyConnection instance.
-   */
   static fromJson(json: string, context?: LoadContext): ApiKeyConnection {
     const data = JSON.parse(json);
-
     return ApiKeyConnection.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a ApiKeyConnection instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ApiKeyConnection instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): ApiKeyConnection {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return ApiKeyConnection.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- *
- *
- */
 export class AnonymousConnection extends Connection {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens)
-   */
   kind: string = "anonymous";
-
-  /**
-   * The endpoint for authenticating with the AI service
-   */
   endpoint: string = "";
 
-  /**
-   * Initializes a new instance of AnonymousConnection.
-   */
   constructor(init?: Partial<AnonymousConnection>) {
     super(init);
-
     this.kind = init?.kind ?? "anonymous";
-
     this.endpoint = init?.endpoint ?? "";
   }
 
   //#region Load Methods
 
-  /**
-   * Load a AnonymousConnection instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded AnonymousConnection instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): AnonymousConnection {
+  static load(data: Record<string, unknown>, context?: LoadContext): AnonymousConnection {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new AnonymousConnection();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["endpoint"] !== undefined && data["endpoint"] !== null) {
       instance.endpoint = String(data["endpoint"]);
     }
@@ -747,15 +426,11 @@ export class AnonymousConnection extends Connection {
 
   //#region Save Methods
 
-  /**
-   * Save the AnonymousConnection instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context
-      ? (context.processObject(this) as AnonymousConnection)
-      : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -763,154 +438,88 @@ export class AnonymousConnection extends Connection {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.endpoint !== undefined && obj.endpoint !== null) {
       result["endpoint"] = obj.endpoint;
     }
-
     return result;
   }
 
-  /**
-   * Convert the AnonymousConnection instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the AnonymousConnection instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a AnonymousConnection instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded AnonymousConnection instance.
-   */
   static fromJson(json: string, context?: LoadContext): AnonymousConnection {
     const data = JSON.parse(json);
-
     return AnonymousConnection.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a AnonymousConnection instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded AnonymousConnection instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): AnonymousConnection {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return AnonymousConnection.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * Connection configuration for Microsoft Foundry projects.
- * Provides project-scoped access to models, tools, and services
- * via Entra ID (DefaultAzureCredential) authentication.
- *
- */
-export class FoundryConnection extends Connection {
-  /**
-   * The shorthand property name for this type, if any.
-   */
+export class OAuthConnection extends Connection {
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The connection kind for Foundry project access
-   */
-  kind: string = "foundry";
-
-  /**
-   * The Foundry project endpoint URL
-   */
+  kind: string = "oauth";
   endpoint: string = "";
+  clientId: string = "";
+  clientSecret: string = "";
+  tokenUrl: string = "";
+  scopes?: string[] = [];
 
-  /**
-   * The named connection within the Foundry project
-   */
-  name?: string | undefined;
-
-  /**
-   * The connection type within the Foundry project (e.g., 'model', 'index', 'storage')
-   */
-  connectionType?: string | undefined;
-
-  /**
-   * Initializes a new instance of FoundryConnection.
-   */
-  constructor(init?: Partial<FoundryConnection>) {
+  constructor(init?: Partial<OAuthConnection>) {
     super(init);
-
-    this.kind = init?.kind ?? "foundry";
-
+    this.kind = init?.kind ?? "oauth";
     this.endpoint = init?.endpoint ?? "";
-
-    if (init?.name !== undefined) {
-      this.name = init.name;
-    }
-
-    if (init?.connectionType !== undefined) {
-      this.connectionType = init.connectionType;
+    this.clientId = init?.clientId ?? "";
+    this.clientSecret = init?.clientSecret ?? "";
+    this.tokenUrl = init?.tokenUrl ?? "";
+    if (init?.scopes !== undefined) {
+      this.scopes = init.scopes;
     }
   }
 
   //#region Load Methods
 
-  /**
-   * Load a FoundryConnection instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded FoundryConnection instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): FoundryConnection {
+  static load(data: Record<string, unknown>, context?: LoadContext): OAuthConnection {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
-    const instance = new FoundryConnection();
+    const instance = new OAuthConnection();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["endpoint"] !== undefined && data["endpoint"] !== null) {
       instance.endpoint = String(data["endpoint"]);
     }
-
-    if (data["name"] !== undefined && data["name"] !== null) {
-      instance.name = String(data["name"]);
+    if (data["clientId"] !== undefined && data["clientId"] !== null) {
+      instance.clientId = String(data["clientId"]);
     }
-
-    if (
-      data["connectionType"] !== undefined &&
-      data["connectionType"] !== null
-    ) {
-      instance.connectionType = String(data["connectionType"]);
+    if (data["clientSecret"] !== undefined && data["clientSecret"] !== null) {
+      instance.clientSecret = String(data["clientSecret"]);
+    }
+    if (data["tokenUrl"] !== undefined && data["tokenUrl"] !== null) {
+      instance.tokenUrl = String(data["tokenUrl"]);
+    }
+    if (data["scopes"] !== undefined && data["scopes"] !== null) {
+      instance.scopes = (data["scopes"] as unknown[]).map(v => String(v));
     }
 
     if (context) {
-      return context.processOutput(instance) as FoundryConnection;
+      return context.processOutput(instance) as OAuthConnection;
     }
     return instance;
   }
@@ -919,15 +528,11 @@ export class FoundryConnection extends Connection {
 
   //#region Save Methods
 
-  /**
-   * Save the FoundryConnection instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context
-      ? (context.processObject(this) as FoundryConnection)
-      : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -935,181 +540,92 @@ export class FoundryConnection extends Connection {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.endpoint !== undefined && obj.endpoint !== null) {
       result["endpoint"] = obj.endpoint;
     }
-
-    if (obj.name !== undefined && obj.name !== null) {
-      result["name"] = obj.name;
+    if (obj.clientId !== undefined && obj.clientId !== null) {
+      result["clientId"] = obj.clientId;
     }
-
-    if (obj.connectionType !== undefined && obj.connectionType !== null) {
-      result["connectionType"] = obj.connectionType;
+    if (obj.clientSecret !== undefined && obj.clientSecret !== null) {
+      result["clientSecret"] = obj.clientSecret;
+    }
+    if (obj.tokenUrl !== undefined && obj.tokenUrl !== null) {
+      result["tokenUrl"] = obj.tokenUrl;
+    }
+    if (obj.scopes !== undefined && obj.scopes !== null) {
+      result["scopes"] = obj.scopes;
     }
-
     return result;
   }
 
-  /**
-   * Convert the FoundryConnection instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the FoundryConnection instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a FoundryConnection instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded FoundryConnection instance.
-   */
-  static fromJson(json: string, context?: LoadContext): FoundryConnection {
+  static fromJson(json: string, context?: LoadContext): OAuthConnection {
     const data = JSON.parse(json);
-
-    return FoundryConnection.load(data as Record<string, unknown>, context);
+    return OAuthConnection.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a FoundryConnection instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded FoundryConnection instance.
-   */
-  static fromYaml(yaml: string, context?: LoadContext): FoundryConnection {
+  static fromYaml(yaml: string, context?: LoadContext): OAuthConnection {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
-    return FoundryConnection.load(data as Record<string, unknown>, context);
+    return OAuthConnection.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * Connection configuration using OAuth 2.0 client credentials.
- * Useful for tools and services that require OAuth authentication,
- * such as MCP servers, OpenAPI endpoints, or other REST APIs.
- *
- */
-export class OAuthConnection extends Connection {
-  /**
-   * The shorthand property name for this type, if any.
-   */
+export class FoundryConnection extends Connection {
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The connection kind for OAuth authentication
-   */
-  kind: string = "oauth";
-
-  /**
-   * The endpoint URL for the service
-   */
+  kind: string = "foundry";
   endpoint: string = "";
+  name?: string | undefined;
+  connectionType?: string | undefined;
 
-  /**
-   * The OAuth client ID
-   */
-  clientId: string = "";
-
-  /**
-   * The OAuth client secret
-   */
-  clientSecret: string = "";
-
-  /**
-   * The OAuth token endpoint URL
-   */
-  tokenUrl: string = "";
-
-  /**
-   * OAuth scopes to request
-   */
-  scopes?: string[] = [];
-
-  /**
-   * Initializes a new instance of OAuthConnection.
-   */
-  constructor(init?: Partial<OAuthConnection>) {
+  constructor(init?: Partial<FoundryConnection>) {
     super(init);
-
-    this.kind = init?.kind ?? "oauth";
-
+    this.kind = init?.kind ?? "foundry";
     this.endpoint = init?.endpoint ?? "";
-
-    this.clientId = init?.clientId ?? "";
-
-    this.clientSecret = init?.clientSecret ?? "";
-
-    this.tokenUrl = init?.tokenUrl ?? "";
-
-    if (init?.scopes !== undefined) {
-      this.scopes = init.scopes;
+    if (init?.name !== undefined) {
+      this.name = init.name;
+    }
+    if (init?.connectionType !== undefined) {
+      this.connectionType = init.connectionType;
     }
   }
 
   //#region Load Methods
 
-  /**
-   * Load a OAuthConnection instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded OAuthConnection instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): OAuthConnection {
+  static load(data: Record<string, unknown>, context?: LoadContext): FoundryConnection {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
-    const instance = new OAuthConnection();
+    const instance = new FoundryConnection();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["endpoint"] !== undefined && data["endpoint"] !== null) {
       instance.endpoint = String(data["endpoint"]);
     }
-
-    if (data["clientId"] !== undefined && data["clientId"] !== null) {
-      instance.clientId = String(data["clientId"]);
-    }
-
-    if (data["clientSecret"] !== undefined && data["clientSecret"] !== null) {
-      instance.clientSecret = String(data["clientSecret"]);
-    }
-
-    if (data["tokenUrl"] !== undefined && data["tokenUrl"] !== null) {
-      instance.tokenUrl = String(data["tokenUrl"]);
+    if (data["name"] !== undefined && data["name"] !== null) {
+      instance.name = String(data["name"]);
     }
-
-    if (data["scopes"] !== undefined && data["scopes"] !== null) {
-      instance.scopes = Array.isArray(data["scopes"])
-        ? (data["scopes"] as unknown[]).map((v) => String(v))
-        : [];
+    if (data["connectionType"] !== undefined && data["connectionType"] !== null) {
+      instance.connectionType = String(data["connectionType"]);
     }
 
     if (context) {
-      return context.processOutput(instance) as OAuthConnection;
+      return context.processOutput(instance) as FoundryConnection;
     }
     return instance;
   }
@@ -1118,15 +634,11 @@ export class OAuthConnection extends Connection {
 
   //#region Save Methods
 
-  /**
-   * Save the OAuthConnection instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context
-      ? (context.processObject(this) as OAuthConnection)
-      : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -1134,75 +646,39 @@ export class OAuthConnection extends Connection {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.endpoint !== undefined && obj.endpoint !== null) {
       result["endpoint"] = obj.endpoint;
     }
-
-    if (obj.clientId !== undefined && obj.clientId !== null) {
-      result["clientId"] = obj.clientId;
-    }
-
-    if (obj.clientSecret !== undefined && obj.clientSecret !== null) {
-      result["clientSecret"] = obj.clientSecret;
-    }
-
-    if (obj.tokenUrl !== undefined && obj.tokenUrl !== null) {
-      result["tokenUrl"] = obj.tokenUrl;
+    if (obj.name !== undefined && obj.name !== null) {
+      result["name"] = obj.name;
     }
-
-    if (obj.scopes !== undefined && obj.scopes !== null) {
-      result["scopes"] = obj.scopes;
+    if (obj.connectionType !== undefined && obj.connectionType !== null) {
+      result["connectionType"] = obj.connectionType;
     }
-
     return result;
   }
 
-  /**
-   * Convert the OAuthConnection instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the OAuthConnection instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a OAuthConnection instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded OAuthConnection instance.
-   */
-  static fromJson(json: string, context?: LoadContext): OAuthConnection {
+  static fromJson(json: string, context?: LoadContext): FoundryConnection {
     const data = JSON.parse(json);
-
-    return OAuthConnection.load(data as Record<string, unknown>, context);
+    return FoundryConnection.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a OAuthConnection instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded OAuthConnection instance.
-   */
-  static fromYaml(yaml: string, context?: LoadContext): OAuthConnection {
+  static fromYaml(yaml: string, context?: LoadContext): FoundryConnection {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
-    return OAuthConnection.load(data as Record<string, unknown>, context);
+    return FoundryConnection.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/content-part.ts b/runtime/typescript/packages/core/src/model/content-part.ts
new file mode 100644
index 00000000..26070512
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/content-part.ts
@@ -0,0 +1,460 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export abstract class ContentPart {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "";
+
+  constructor(init?: Partial<ContentPart>) {
+    this.kind = init?.kind ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ContentPart {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    // Load polymorphic ContentPart instance
+    const instance = ContentPart.loadKind(data, context);
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ContentPart;
+    }
+    return instance;
+  }
+
+  private static loadKind(data: Record<string, unknown>, context?: LoadContext): ContentPart {
+    const discriminatorValue = data["kind"];
+    if (discriminatorValue !== undefined && discriminatorValue !== null) {
+      const discriminator = String(discriminatorValue).toLowerCase();
+      switch (discriminator) {
+        case "text":
+          return TextPart.load(data, context);
+        case "image":
+          return ImagePart.load(data, context);
+        case "file":
+          return FilePart.load(data, context);
+        case "audio":
+          return AudioPart.load(data, context);
+        default:
+          throw new Error(`Unknown ContentPart discriminator value: ${discriminator}`);
+      }
+    }
+    throw new Error("Missing ContentPart discriminator property: 'kind'");
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ContentPart {
+    const data = JSON.parse(json);
+    return ContentPart.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ContentPart {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ContentPart.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
+export class TextPart extends ContentPart {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "text";
+  value: string = "";
+
+  constructor(init?: Partial<TextPart>) {
+    super(init);
+    this.kind = init?.kind ?? "text";
+    this.value = init?.value ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): TextPart {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new TextPart();
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+    if (data["value"] !== undefined && data["value"] !== null) {
+      instance.value = String(data["value"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as TextPart;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    // Start with parent class properties
+    const result = super.save(context);
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+    if (obj.value !== undefined && obj.value !== null) {
+      result["value"] = obj.value;
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): TextPart {
+    const data = JSON.parse(json);
+    return TextPart.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): TextPart {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return TextPart.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
+export class ImagePart extends ContentPart {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "image";
+  source: string = "";
+  detail?: string | undefined;
+  mediaType?: string | undefined;
+
+  constructor(init?: Partial<ImagePart>) {
+    super(init);
+    this.kind = init?.kind ?? "image";
+    this.source = init?.source ?? "";
+    if (init?.detail !== undefined) {
+      this.detail = init.detail;
+    }
+    if (init?.mediaType !== undefined) {
+      this.mediaType = init.mediaType;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ImagePart {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ImagePart();
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+    if (data["source"] !== undefined && data["source"] !== null) {
+      instance.source = String(data["source"]);
+    }
+    if (data["detail"] !== undefined && data["detail"] !== null) {
+      instance.detail = String(data["detail"]);
+    }
+    if (data["mediaType"] !== undefined && data["mediaType"] !== null) {
+      instance.mediaType = String(data["mediaType"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ImagePart;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    // Start with parent class properties
+    const result = super.save(context);
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+    if (obj.source !== undefined && obj.source !== null) {
+      result["source"] = obj.source;
+    }
+    if (obj.detail !== undefined && obj.detail !== null) {
+      result["detail"] = obj.detail;
+    }
+    if (obj.mediaType !== undefined && obj.mediaType !== null) {
+      result["mediaType"] = obj.mediaType;
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ImagePart {
+    const data = JSON.parse(json);
+    return ImagePart.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ImagePart {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ImagePart.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
+export class FilePart extends ContentPart {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "file";
+  source: string = "";
+  mediaType?: string | undefined;
+
+  constructor(init?: Partial<FilePart>) {
+    super(init);
+    this.kind = init?.kind ?? "file";
+    this.source = init?.source ?? "";
+    if (init?.mediaType !== undefined) {
+      this.mediaType = init.mediaType;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): FilePart {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new FilePart();
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+    if (data["source"] !== undefined && data["source"] !== null) {
+      instance.source = String(data["source"]);
+    }
+    if (data["mediaType"] !== undefined && data["mediaType"] !== null) {
+      instance.mediaType = String(data["mediaType"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as FilePart;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    // Start with parent class properties
+    const result = super.save(context);
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+    if (obj.source !== undefined && obj.source !== null) {
+      result["source"] = obj.source;
+    }
+    if (obj.mediaType !== undefined && obj.mediaType !== null) {
+      result["mediaType"] = obj.mediaType;
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): FilePart {
+    const data = JSON.parse(json);
+    return FilePart.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): FilePart {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return FilePart.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
+export class AudioPart extends ContentPart {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "audio";
+  source: string = "";
+  mediaType?: string | undefined;
+
+  constructor(init?: Partial<AudioPart>) {
+    super(init);
+    this.kind = init?.kind ?? "audio";
+    this.source = init?.source ?? "";
+    if (init?.mediaType !== undefined) {
+      this.mediaType = init.mediaType;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): AudioPart {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new AudioPart();
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+    if (data["source"] !== undefined && data["source"] !== null) {
+      instance.source = String(data["source"]);
+    }
+    if (data["mediaType"] !== undefined && data["mediaType"] !== null) {
+      instance.mediaType = String(data["mediaType"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as AudioPart;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    // Start with parent class properties
+    const result = super.save(context);
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+    if (obj.source !== undefined && obj.source !== null) {
+      result["source"] = obj.source;
+    }
+    if (obj.mediaType !== undefined && obj.mediaType !== null) {
+      result["mediaType"] = obj.mediaType;
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): AudioPart {
+    const data = JSON.parse(json);
+    return AudioPart.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): AudioPart {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return AudioPart.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/done-event-payload.ts b/runtime/typescript/packages/core/src/model/done-event-payload.ts
new file mode 100644
index 00000000..2a0e9621
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/done-event-payload.ts
@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+import { Message } from "./message";
+
+export class DoneEventPayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  response: string = "";
+  messages: Message[] = [];
+
+  constructor(init?: Partial<DoneEventPayload>) {
+    this.response = init?.response ?? "";
+    this.messages = init?.messages ?? [];
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): DoneEventPayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new DoneEventPayload();
+
+    if (data["response"] !== undefined && data["response"] !== null) {
+      instance.response = String(data["response"]);
+    }
+    if (data["messages"] !== undefined && data["messages"] !== null) {
+      instance.messages = DoneEventPayload.loadMessages(data["messages"] as unknown[], context);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as DoneEventPayload;
+    }
+    return instance;
+  }
+
+  static loadMessages(data: Record<string, unknown>[] | unknown[], context?: LoadContext): Message[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
+        } else {
+          result.push({ name: k, "role": v });
+        }
+      }
+      data = result;
+    }
+    return data.map(item => Message.load(item as Record<string, unknown>, context));
+  }
+
+  static saveMessages(items: Message[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    // This type doesn't have a 'name' property, so always use array format
+    return items.map(item => item.save(context));
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.response !== undefined && obj.response !== null) {
+      result["response"] = obj.response;
+    }
+    if (obj.messages !== undefined && obj.messages !== null) {
+      result["messages"] = DoneEventPayload.saveMessages(obj.messages, context);
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): DoneEventPayload {
+    const data = JSON.parse(json);
+    return DoneEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): DoneEventPayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return DoneEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/error-event-payload.ts b/runtime/typescript/packages/core/src/model/error-event-payload.ts
new file mode 100644
index 00000000..93f6e997
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/error-event-payload.ts
@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class ErrorEventPayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  message: string = "";
+
+  constructor(init?: Partial<ErrorEventPayload>) {
+    this.message = init?.message ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ErrorEventPayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ErrorEventPayload();
+
+    if (data["message"] !== undefined && data["message"] !== null) {
+      instance.message = String(data["message"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ErrorEventPayload;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.message !== undefined && obj.message !== null) {
+      result["message"] = obj.message;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ErrorEventPayload {
+    const data = JSON.parse(json);
+    return ErrorEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ErrorEventPayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ErrorEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/executor.ts b/runtime/typescript/packages/core/src/model/executor.ts
new file mode 100644
index 00000000..ecd4cf81
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/executor.ts
@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { Message } from "./message";
+import { Prompty } from "./prompty";
+import { ToolCall } from "./tool-call";
+
+/** Calls an LLM provider with messages and returns the raw provider response. */
+export interface Executor {
+  /** Call an LLM provider with messages and return the raw response */
+  execute(agent: Prompty, messages: Message[]): Promise<unknown>;
+  /** Call an LLM provider and return a streaming response. Returns a language-specific async iterable/stream of raw chunks. Not all providers support streaming; the default implementation should signal lack of support. */
+  executeStream?(agent: Prompty, messages: Message[]): Promise<unknown>;
+  /** Format tool call results into messages for the next iteration */
+  formatToolMessages(rawResponse: unknown, toolCalls: ToolCall[], toolResults: string[], textContent: string | null): Message[];
+}
+
diff --git a/runtime/typescript/packages/core/src/model/format-config.ts b/runtime/typescript/packages/core/src/model/format-config.ts
index 30865d03..dc400d90 100644
--- a/runtime/typescript/packages/core/src/model/format-config.ts
+++ b/runtime/typescript/packages/core/src/model/format-config.ts
@@ -3,41 +3,18 @@
 
 import { LoadContext, SaveContext } from "./context";
 
-/**
- * Template format definition
- *
- */
 export class FormatConfig {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = "kind";
 
-  /**
-   * Template rendering engine used for slot filling prompts (e.g., mustache, jinja2)
-   */
   kind: string = "*";
-
-  /**
-   * Whether the template can emit structural text for parsing output
-   */
   strict?: boolean | undefined;
+  options?: Record<string, unknown> | undefined;
 
-  /**
-   * Options for the template engine
-   */
-  options?: Record<string, unknown> | undefined = {};
-
-  /**
-   * Initializes a new instance of FormatConfig.
-   */
   constructor(init?: Partial<FormatConfig>) {
     this.kind = init?.kind ?? "*";
-
     if (init?.strict !== undefined) {
       this.strict = init.strict;
     }
-
     if (init?.options !== undefined) {
       this.options = init.options;
     }
@@ -45,38 +22,29 @@ export class FormatConfig {
 
   //#region Load Methods
 
-  /**
-   * Load a FormatConfig instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded FormatConfig instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): FormatConfig {
+  static load(data: Record<string, unknown>, context?: LoadContext): FormatConfig {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
     // Handle alternate representations
     if (typeof data === "string") {
-      data = { kind: data };
-    } else if (typeof data === "number") {
-    } else if (typeof data === "boolean") {
+      const instance = new FormatConfig();
+      instance.kind = data as string;
+      if (context) {
+        return context.processOutput(instance) as FormatConfig;
+      }
+      return instance;
     }
 
-    // Create new instance
     const instance = new FormatConfig();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["strict"] !== undefined && data["strict"] !== null) {
       instance.strict = Boolean(data["strict"]);
     }
-
     if (data["options"] !== undefined && data["options"] !== null) {
       instance.options = data["options"] as Record<string, unknown>;
     }
@@ -91,24 +59,20 @@ export class FormatConfig {
 
   //#region Save Methods
 
-  /**
-   * Save the FormatConfig instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as FormatConfig) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.strict !== undefined && obj.strict !== null) {
       result["strict"] = obj.strict;
     }
-
     if (obj.options !== undefined && obj.options !== null) {
       result["options"] = obj.options;
     }
@@ -116,85 +80,30 @@ export class FormatConfig {
     if (context) {
       return context.processDict(result);
     }
-
     return result;
   }
 
-  /**
-   * Convert the FormatConfig instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the FormatConfig instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a FormatConfig instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded FormatConfig instance.
-   */
   static fromJson(json: string, context?: LoadContext): FormatConfig {
     const data = JSON.parse(json);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return FormatConfig.load({ kind: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return FormatConfig.load({ kind: data }, context);
-    }
-
     return FormatConfig.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a FormatConfig instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded FormatConfig instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): FormatConfig {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return FormatConfig.load({ kind: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return FormatConfig.load({ kind: data }, context);
-    }
-
     return FormatConfig.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/guardrail-result.ts b/runtime/typescript/packages/core/src/model/guardrail-result.ts
new file mode 100644
index 00000000..5b3cf47c
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/guardrail-result.ts
@@ -0,0 +1,112 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class GuardrailResult {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  allowed: boolean = false;
+  reason?: string | undefined;
+  rewrite?: unknown | undefined;
+
+  constructor(init?: Partial<GuardrailResult>) {
+    this.allowed = init?.allowed ?? false;
+    if (init?.reason !== undefined) {
+      this.reason = init.reason;
+    }
+    if (init?.rewrite !== undefined) {
+      this.rewrite = init.rewrite;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): GuardrailResult {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new GuardrailResult();
+
+    if (data["allowed"] !== undefined && data["allowed"] !== null) {
+      instance.allowed = Boolean(data["allowed"]);
+    }
+    if (data["reason"] !== undefined && data["reason"] !== null) {
+      instance.reason = String(data["reason"]);
+    }
+    if (data["rewrite"] !== undefined && data["rewrite"] !== null) {
+      instance.rewrite = data["rewrite"] as unknown;
+    }
+
+    if (context) {
+      return context.processOutput(instance) as GuardrailResult;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.allowed !== undefined && obj.allowed !== null) {
+      result["allowed"] = obj.allowed;
+    }
+    if (obj.reason !== undefined && obj.reason !== null) {
+      result["reason"] = obj.reason;
+    }
+    if (obj.rewrite !== undefined && obj.rewrite !== null) {
+      result["rewrite"] = obj.rewrite;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): GuardrailResult {
+    const data = JSON.parse(json);
+    return GuardrailResult.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): GuardrailResult {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return GuardrailResult.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+
+  static rewrite(rewrite: unknown): GuardrailResult {
+    return new GuardrailResult({ allowed: true, rewrite: rewrite });
+  }
+
+  static deny(reason: string): GuardrailResult {
+    return new GuardrailResult({ allowed: false, reason: reason });
+  }
+
+  static allow(): GuardrailResult {
+    return new GuardrailResult({ allowed: true });
+  }
+
+}
+
diff --git a/runtime/typescript/packages/core/src/model/index.ts b/runtime/typescript/packages/core/src/model/index.ts
index 87c60b20..85516592 100644
--- a/runtime/typescript/packages/core/src/model/index.ts
+++ b/runtime/typescript/packages/core/src/model/index.ts
@@ -3,7 +3,11 @@
 
 export { LoadContext, SaveContext } from "./context";
 
-export { Property, ArrayProperty, ObjectProperty } from "./property";
+export {
+  Property,
+  ArrayProperty,
+  ObjectProperty,
+} from "./property";
 
 export {
   Connection,
@@ -11,14 +15,11 @@ export {
   RemoteConnection,
   ApiKeyConnection,
   AnonymousConnection,
-  FoundryConnection,
   OAuthConnection,
+  FoundryConnection,
 } from "./connection";
-
 export { ModelOptions } from "./model-options";
-
 export { Model } from "./model";
-
 export { Binding } from "./binding";
 
 export {
@@ -29,13 +30,49 @@ export {
   OpenApiTool,
   PromptyTool,
 } from "./tool";
-
 export { McpApprovalMode } from "./mcp-approval-mode";
-
 export { FormatConfig } from "./format-config";
-
 export { ParserConfig } from "./parser-config";
-
 export { Template } from "./template";
-
 export { Prompty } from "./prompty";
+
+export {
+  ContentPart,
+  TextPart,
+  ImagePart,
+  FilePart,
+  AudioPart,
+} from "./content-part";
+export { Message } from "./message";
+export { ToolContext } from "./tool-context";
+export { ToolResult } from "./tool-result";
+export { ToolDispatchResult } from "./tool-dispatch-result";
+export { ToolCall } from "./tool-call";
+export { GuardrailResult } from "./guardrail-result";
+export { ThreadMarker } from "./thread-marker";
+export { TokenUsage } from "./token-usage";
+export { ModelInfo } from "./model-info";
+export { CompactionConfig } from "./compaction-config";
+export { TurnOptions } from "./turn-options";
+export type { Renderer } from "./renderer";
+export type { Parser } from "./parser";
+export type { Executor } from "./executor";
+export type { Processor } from "./processor";
+export { TokenEventPayload } from "./token-event-payload";
+export { ThinkingEventPayload } from "./thinking-event-payload";
+export { ToolCallStartPayload } from "./tool-call-start-payload";
+export { ToolResultPayload } from "./tool-result-payload";
+export { StatusEventPayload } from "./status-event-payload";
+export { MessagesUpdatedPayload } from "./messages-updated-payload";
+export { DoneEventPayload } from "./done-event-payload";
+export { ErrorEventPayload } from "./error-event-payload";
+export { CompactionCompletePayload } from "./compaction-complete-payload";
+export { CompactionFailedPayload } from "./compaction-failed-payload";
+
+export {
+  StreamChunk,
+  TextChunk,
+  ThinkingChunk,
+  ToolChunk,
+  ErrorChunk,
+} from "./stream-chunk";
diff --git a/runtime/typescript/packages/core/src/model/mcp-approval-mode.ts b/runtime/typescript/packages/core/src/model/mcp-approval-mode.ts
index d6319ecb..a34ee688 100644
--- a/runtime/typescript/packages/core/src/model/mcp-approval-mode.ts
+++ b/runtime/typescript/packages/core/src/model/mcp-approval-mode.ts
@@ -3,43 +3,18 @@
 
 import { LoadContext, SaveContext } from "./context";
 
-/**
- * The approval mode for MCP server tools.
- * When kind is "specify", use alwaysRequireApprovalTools and neverRequireApprovalTools
- * to control per-tool approval. For "always" and "never", those fields are ignored.
- *
- */
 export class McpApprovalMode {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = "kind";
 
-  /**
-   * The approval mode: 'always', 'never', or 'specify'
-   */
   kind: string = "";
-
-  /**
-   * List of tools that always require approval (only used when kind is 'specify')
-   */
   alwaysRequireApprovalTools?: string[] = [];
-
-  /**
-   * List of tools that never require approval (only used when kind is 'specify')
-   */
   neverRequireApprovalTools?: string[] = [];
 
-  /**
-   * Initializes a new instance of McpApprovalMode.
-   */
   constructor(init?: Partial<McpApprovalMode>) {
     this.kind = init?.kind ?? "";
-
     if (init?.alwaysRequireApprovalTools !== undefined) {
       this.alwaysRequireApprovalTools = init.alwaysRequireApprovalTools;
     }
-
     if (init?.neverRequireApprovalTools !== undefined) {
       this.neverRequireApprovalTools = init.neverRequireApprovalTools;
     }
@@ -47,56 +22,31 @@ export class McpApprovalMode {
 
   //#region Load Methods
 
-  /**
-   * Load a McpApprovalMode instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded McpApprovalMode instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): McpApprovalMode {
+  static load(data: Record<string, unknown>, context?: LoadContext): McpApprovalMode {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
     // Handle alternate representations
     if (typeof data === "string") {
-      data = { kind: data };
-    } else if (typeof data === "number") {
-    } else if (typeof data === "boolean") {
+      const instance = new McpApprovalMode();
+      instance.kind = data as string;
+      if (context) {
+        return context.processOutput(instance) as McpApprovalMode;
+      }
+      return instance;
     }
 
-    // Create new instance
     const instance = new McpApprovalMode();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
-    if (
-      data["alwaysRequireApprovalTools"] !== undefined &&
-      data["alwaysRequireApprovalTools"] !== null
-    ) {
-      instance.alwaysRequireApprovalTools = Array.isArray(
-        data["alwaysRequireApprovalTools"],
-      )
-        ? (data["alwaysRequireApprovalTools"] as unknown[]).map((v) =>
-            String(v),
-          )
-        : [];
+    if (data["alwaysRequireApprovalTools"] !== undefined && data["alwaysRequireApprovalTools"] !== null) {
+      instance.alwaysRequireApprovalTools = (data["alwaysRequireApprovalTools"] as unknown[]).map(v => String(v));
     }
-
-    if (
-      data["neverRequireApprovalTools"] !== undefined &&
-      data["neverRequireApprovalTools"] !== null
-    ) {
-      instance.neverRequireApprovalTools = Array.isArray(
-        data["neverRequireApprovalTools"],
-      )
-        ? (data["neverRequireApprovalTools"] as unknown[]).map((v) => String(v))
-        : [];
+    if (data["neverRequireApprovalTools"] !== undefined && data["neverRequireApprovalTools"] !== null) {
+      instance.neverRequireApprovalTools = (data["neverRequireApprovalTools"] as unknown[]).map(v => String(v));
     }
 
     if (context) {
@@ -109,118 +59,51 @@ export class McpApprovalMode {
 
   //#region Save Methods
 
-  /**
-   * Save the McpApprovalMode instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context
-      ? (context.processObject(this) as McpApprovalMode)
-      : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
-    if (
-      obj.alwaysRequireApprovalTools !== undefined &&
-      obj.alwaysRequireApprovalTools !== null
-    ) {
+    if (obj.alwaysRequireApprovalTools !== undefined && obj.alwaysRequireApprovalTools !== null) {
       result["alwaysRequireApprovalTools"] = obj.alwaysRequireApprovalTools;
     }
-
-    if (
-      obj.neverRequireApprovalTools !== undefined &&
-      obj.neverRequireApprovalTools !== null
-    ) {
+    if (obj.neverRequireApprovalTools !== undefined && obj.neverRequireApprovalTools !== null) {
       result["neverRequireApprovalTools"] = obj.neverRequireApprovalTools;
     }
 
     if (context) {
       return context.processDict(result);
     }
-
     return result;
   }
 
-  /**
-   * Convert the McpApprovalMode instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the McpApprovalMode instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a McpApprovalMode instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded McpApprovalMode instance.
-   */
   static fromJson(json: string, context?: LoadContext): McpApprovalMode {
     const data = JSON.parse(json);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return McpApprovalMode.load({ kind: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return McpApprovalMode.load({ kind: data }, context);
-    }
-
     return McpApprovalMode.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a McpApprovalMode instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded McpApprovalMode instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): McpApprovalMode {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return McpApprovalMode.load({ kind: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return McpApprovalMode.load({ kind: data }, context);
-    }
-
     return McpApprovalMode.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/message.ts b/runtime/typescript/packages/core/src/model/message.ts
new file mode 100644
index 00000000..ba8867ba
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/message.ts
@@ -0,0 +1,149 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+import { ContentPart, TextPart } from "./content-part";
+
+export class Message {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  role: string = "user";
+  parts: ContentPart[] = [];
+  metadata: Record<string, unknown> = {};
+
+  constructor(init?: Partial<Message>) {
+    this.role = init?.role ?? "user";
+    this.parts = init?.parts ?? [];
+    this.metadata = init?.metadata ?? {};
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): Message {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new Message();
+
+    if (data["role"] !== undefined && data["role"] !== null) {
+      instance.role = String(data["role"]);
+    }
+    if (data["parts"] !== undefined && data["parts"] !== null) {
+      instance.parts = Message.loadParts(data["parts"] as unknown[], context);
+    }
+    if (data["metadata"] !== undefined && data["metadata"] !== null) {
+      instance.metadata = data["metadata"] as Record<string, unknown>;
+    }
+
+    if (context) {
+      return context.processOutput(instance) as Message;
+    }
+    return instance;
+  }
+
+  static loadParts(data: Record<string, unknown>[] | unknown[], context?: LoadContext): ContentPart[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
+        } else {
+          result.push({ name: k, "kind": v });
+        }
+      }
+      data = result;
+    }
+    return data.map(item => ContentPart.load(item as Record<string, unknown>, context));
+  }
+
+  static saveParts(items: ContentPart[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    // This type doesn't have a 'name' property, so always use array format
+    return items.map(item => item.save(context));
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.role !== undefined && obj.role !== null) {
+      result["role"] = obj.role;
+    }
+    if (obj.parts !== undefined && obj.parts !== null) {
+      result["parts"] = Message.saveParts(obj.parts, context);
+    }
+    if (obj.metadata !== undefined && obj.metadata !== null) {
+      result["metadata"] = obj.metadata;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): Message {
+    const data = JSON.parse(json);
+    return Message.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): Message {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return Message.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+
+  static assistant(text: string): Message {
+    return new Message({ role: "assistant", parts: [new TextPart({ value: text })] });
+  }
+
+  static system(text: string): Message {
+    return new Message({ role: "system", parts: [new TextPart({ value: text })] });
+  }
+
+  static user(text: string): Message {
+    return new Message({ role: "user", parts: [new TextPart({ value: text })] });
+  }
+
+}
+
+/**
+ * Helper contract for `Message`.
+ *
+ * Runtime implementations must provide these methods on every Message
+ * instance (either on the generated class or on a wrapper type). The
+ * TypeScript compiler enforces conformance wherever a value is typed as
+ * `MessageHelpers`.
+ */
+export interface MessageHelpers {
+  /** Return plain string if all parts are text, else a list of content part dicts for wire serialization */
+  toTextContent(): unknown;
+  /** Concatenate all TextPart values joined by newline */
+  readonly text: string;
+}
+
diff --git a/runtime/typescript/packages/core/src/model/messages-updated-payload.ts b/runtime/typescript/packages/core/src/model/messages-updated-payload.ts
new file mode 100644
index 00000000..5f5c1f8a
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/messages-updated-payload.ts
@@ -0,0 +1,105 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+import { Message } from "./message";
+
+export class MessagesUpdatedPayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  messages: Message[] = [];
+
+  constructor(init?: Partial<MessagesUpdatedPayload>) {
+    this.messages = init?.messages ?? [];
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): MessagesUpdatedPayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new MessagesUpdatedPayload();
+
+    if (data["messages"] !== undefined && data["messages"] !== null) {
+      instance.messages = MessagesUpdatedPayload.loadMessages(data["messages"] as unknown[], context);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as MessagesUpdatedPayload;
+    }
+    return instance;
+  }
+
+  static loadMessages(data: Record<string, unknown>[] | unknown[], context?: LoadContext): Message[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
+        } else {
+          result.push({ name: k, "role": v });
+        }
+      }
+      data = result;
+    }
+    return data.map(item => Message.load(item as Record<string, unknown>, context));
+  }
+
+  static saveMessages(items: Message[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    // This type doesn't have a 'name' property, so always use array format
+    return items.map(item => item.save(context));
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.messages !== undefined && obj.messages !== null) {
+      result["messages"] = MessagesUpdatedPayload.saveMessages(obj.messages, context);
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): MessagesUpdatedPayload {
+    const data = JSON.parse(json);
+    return MessagesUpdatedPayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): MessagesUpdatedPayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return MessagesUpdatedPayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/model-info.ts b/runtime/typescript/packages/core/src/model/model-info.ts
new file mode 100644
index 00000000..dfb227c1
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/model-info.ts
@@ -0,0 +1,139 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class ModelInfo {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  id: string = "";
+  displayName?: string | undefined;
+  ownedBy?: string | undefined;
+  contextWindow?: number | undefined;
+  inputModalities?: string[] = [];
+  outputModalities?: string[] = [];
+  additionalProperties?: Record<string, unknown> | undefined;
+
+  constructor(init?: Partial<ModelInfo>) {
+    this.id = init?.id ?? "";
+    if (init?.displayName !== undefined) {
+      this.displayName = init.displayName;
+    }
+    if (init?.ownedBy !== undefined) {
+      this.ownedBy = init.ownedBy;
+    }
+    if (init?.contextWindow !== undefined) {
+      this.contextWindow = init.contextWindow;
+    }
+    if (init?.inputModalities !== undefined) {
+      this.inputModalities = init.inputModalities;
+    }
+    if (init?.outputModalities !== undefined) {
+      this.outputModalities = init.outputModalities;
+    }
+    if (init?.additionalProperties !== undefined) {
+      this.additionalProperties = init.additionalProperties;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ModelInfo {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ModelInfo();
+
+    if (data["id"] !== undefined && data["id"] !== null) {
+      instance.id = String(data["id"]);
+    }
+    if (data["displayName"] !== undefined && data["displayName"] !== null) {
+      instance.displayName = String(data["displayName"]);
+    }
+    if (data["ownedBy"] !== undefined && data["ownedBy"] !== null) {
+      instance.ownedBy = String(data["ownedBy"]);
+    }
+    if (data["contextWindow"] !== undefined && data["contextWindow"] !== null) {
+      instance.contextWindow = Number(data["contextWindow"]);
+    }
+    if (data["inputModalities"] !== undefined && data["inputModalities"] !== null) {
+      instance.inputModalities = (data["inputModalities"] as unknown[]).map(v => String(v));
+    }
+    if (data["outputModalities"] !== undefined && data["outputModalities"] !== null) {
+      instance.outputModalities = (data["outputModalities"] as unknown[]).map(v => String(v));
+    }
+    if (data["additionalProperties"] !== undefined && data["additionalProperties"] !== null) {
+      instance.additionalProperties = data["additionalProperties"] as Record<string, unknown>;
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ModelInfo;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.id !== undefined && obj.id !== null) {
+      result["id"] = obj.id;
+    }
+    if (obj.displayName !== undefined && obj.displayName !== null) {
+      result["displayName"] = obj.displayName;
+    }
+    if (obj.ownedBy !== undefined && obj.ownedBy !== null) {
+      result["ownedBy"] = obj.ownedBy;
+    }
+    if (obj.contextWindow !== undefined && obj.contextWindow !== null) {
+      result["contextWindow"] = obj.contextWindow;
+    }
+    if (obj.inputModalities !== undefined && obj.inputModalities !== null) {
+      result["inputModalities"] = obj.inputModalities;
+    }
+    if (obj.outputModalities !== undefined && obj.outputModalities !== null) {
+      result["outputModalities"] = obj.outputModalities;
+    }
+    if (obj.additionalProperties !== undefined && obj.additionalProperties !== null) {
+      result["additionalProperties"] = obj.additionalProperties;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ModelInfo {
+    const data = JSON.parse(json);
+    return ModelInfo.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ModelInfo {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ModelInfo.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/model-options.ts b/runtime/typescript/packages/core/src/model/model-options.ts
index 485d9a0b..c66654b0 100644
--- a/runtime/typescript/packages/core/src/model/model-options.ts
+++ b/runtime/typescript/packages/core/src/model/model-options.ts
@@ -3,106 +3,48 @@
 
 import { LoadContext, SaveContext } from "./context";
 
-/**
- * Options for configuring the behavior of the AI model.
- *
- */
 export class ModelOptions {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The frequency penalty to apply to the model's output
-   */
   frequencyPenalty?: number | undefined;
-
-  /**
-   * The maximum number of tokens to generate in the output
-   */
   maxOutputTokens?: number | undefined;
-
-  /**
-   * The presence penalty to apply to the model's output
-   */
   presencePenalty?: number | undefined;
-
-  /**
-   * A random seed for deterministic output
-   */
   seed?: number | undefined;
-
-  /**
-   * The temperature to use for sampling
-   */
   temperature?: number | undefined;
-
-  /**
-   * The top-K sampling value
-   */
   topK?: number | undefined;
-
-  /**
-   * The top-P sampling value
-   */
   topP?: number | undefined;
-
-  /**
-   * Stop sequences to end generation
-   */
   stopSequences?: string[] = [];
-
-  /**
-   * Whether to allow multiple tool calls in a single response
-   */
   allowMultipleToolCalls?: boolean | undefined;
+  additionalProperties?: Record<string, unknown> | undefined;
 
-  /**
-   * Additional custom properties for model options
-   */
-  additionalProperties?: Record<string, unknown> | undefined = {};
-
-  /**
-   * Initializes a new instance of ModelOptions.
-   */
   constructor(init?: Partial<ModelOptions>) {
     if (init?.frequencyPenalty !== undefined) {
       this.frequencyPenalty = init.frequencyPenalty;
     }
-
     if (init?.maxOutputTokens !== undefined) {
       this.maxOutputTokens = init.maxOutputTokens;
     }
-
     if (init?.presencePenalty !== undefined) {
       this.presencePenalty = init.presencePenalty;
     }
-
     if (init?.seed !== undefined) {
       this.seed = init.seed;
     }
-
     if (init?.temperature !== undefined) {
       this.temperature = init.temperature;
     }
-
     if (init?.topK !== undefined) {
       this.topK = init.topK;
     }
-
     if (init?.topP !== undefined) {
       this.topP = init.topP;
     }
-
     if (init?.stopSequences !== undefined) {
       this.stopSequences = init.stopSequences;
     }
-
     if (init?.allowMultipleToolCalls !== undefined) {
       this.allowMultipleToolCalls = init.allowMultipleToolCalls;
     }
-
     if (init?.additionalProperties !== undefined) {
       this.additionalProperties = init.additionalProperties;
     }
@@ -110,81 +52,42 @@ export class ModelOptions {
 
   //#region Load Methods
 
-  /**
-   * Load a ModelOptions instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ModelOptions instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): ModelOptions {
+  static load(data: Record<string, unknown>, context?: LoadContext): ModelOptions {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new ModelOptions();
 
-    if (
-      data["frequencyPenalty"] !== undefined &&
-      data["frequencyPenalty"] !== null
-    ) {
+    if (data["frequencyPenalty"] !== undefined && data["frequencyPenalty"] !== null) {
       instance.frequencyPenalty = Number(data["frequencyPenalty"]);
     }
-
-    if (
-      data["maxOutputTokens"] !== undefined &&
-      data["maxOutputTokens"] !== null
-    ) {
+    if (data["maxOutputTokens"] !== undefined && data["maxOutputTokens"] !== null) {
       instance.maxOutputTokens = Number(data["maxOutputTokens"]);
     }
-
-    if (
-      data["presencePenalty"] !== undefined &&
-      data["presencePenalty"] !== null
-    ) {
+    if (data["presencePenalty"] !== undefined && data["presencePenalty"] !== null) {
       instance.presencePenalty = Number(data["presencePenalty"]);
     }
-
     if (data["seed"] !== undefined && data["seed"] !== null) {
       instance.seed = Number(data["seed"]);
     }
-
     if (data["temperature"] !== undefined && data["temperature"] !== null) {
       instance.temperature = Number(data["temperature"]);
     }
-
     if (data["topK"] !== undefined && data["topK"] !== null) {
       instance.topK = Number(data["topK"]);
     }
-
     if (data["topP"] !== undefined && data["topP"] !== null) {
       instance.topP = Number(data["topP"]);
     }
-
     if (data["stopSequences"] !== undefined && data["stopSequences"] !== null) {
-      instance.stopSequences = Array.isArray(data["stopSequences"])
-        ? (data["stopSequences"] as unknown[]).map((v) => String(v))
-        : [];
+      instance.stopSequences = (data["stopSequences"] as unknown[]).map(v => String(v));
     }
-
-    if (
-      data["allowMultipleToolCalls"] !== undefined &&
-      data["allowMultipleToolCalls"] !== null
-    ) {
+    if (data["allowMultipleToolCalls"] !== undefined && data["allowMultipleToolCalls"] !== null) {
       instance.allowMultipleToolCalls = Boolean(data["allowMultipleToolCalls"]);
     }
-
-    if (
-      data["additionalProperties"] !== undefined &&
-      data["additionalProperties"] !== null
-    ) {
-      instance.additionalProperties = data["additionalProperties"] as Record<
-        string,
-        unknown
-      >;
+    if (data["additionalProperties"] !== undefined && data["additionalProperties"] !== null) {
+      instance.additionalProperties = data["additionalProperties"] as Record<string, unknown>;
     }
 
     if (context) {
@@ -197,114 +100,95 @@ export class ModelOptions {
 
   //#region Save Methods
 
-  /**
-   * Save the ModelOptions instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as ModelOptions) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.frequencyPenalty !== undefined && obj.frequencyPenalty !== null) {
       result["frequencyPenalty"] = obj.frequencyPenalty;
     }
-
     if (obj.maxOutputTokens !== undefined && obj.maxOutputTokens !== null) {
       result["maxOutputTokens"] = obj.maxOutputTokens;
     }
-
     if (obj.presencePenalty !== undefined && obj.presencePenalty !== null) {
       result["presencePenalty"] = obj.presencePenalty;
     }
-
     if (obj.seed !== undefined && obj.seed !== null) {
       result["seed"] = obj.seed;
     }
-
     if (obj.temperature !== undefined && obj.temperature !== null) {
       result["temperature"] = obj.temperature;
     }
-
     if (obj.topK !== undefined && obj.topK !== null) {
       result["topK"] = obj.topK;
     }
-
     if (obj.topP !== undefined && obj.topP !== null) {
       result["topP"] = obj.topP;
     }
-
     if (obj.stopSequences !== undefined && obj.stopSequences !== null) {
       result["stopSequences"] = obj.stopSequences;
     }
-
-    if (
-      obj.allowMultipleToolCalls !== undefined &&
-      obj.allowMultipleToolCalls !== null
-    ) {
+    if (obj.allowMultipleToolCalls !== undefined && obj.allowMultipleToolCalls !== null) {
       result["allowMultipleToolCalls"] = obj.allowMultipleToolCalls;
     }
-
-    if (
-      obj.additionalProperties !== undefined &&
-      obj.additionalProperties !== null
-    ) {
+    if (obj.additionalProperties !== undefined && obj.additionalProperties !== null) {
       result["additionalProperties"] = obj.additionalProperties;
     }
 
     if (context) {
       return context.processDict(result);
     }
+    return result;
+  }
 
+  toWire(provider: string): Record<string, unknown> {
+    const data = this.save();
+    const result: Record<string, unknown> = {};
+    const wireMap: Record<string, Record<string, string>> = {
+      "frequencyPenalty": { "openai": "frequency_penalty" },
+      "maxOutputTokens": { "openai": "max_completion_tokens", "responses": "max_output_tokens", "anthropic": "max_tokens" },
+      "presencePenalty": { "openai": "presence_penalty" },
+      "seed": { "openai": "seed" },
+      "temperature": { "openai": "temperature", "responses": "temperature", "anthropic": "temperature" },
+      "topK": { "openai": "top_k", "anthropic": "top_k" },
+      "topP": { "openai": "top_p", "responses": "top_p", "anthropic": "top_p" },
+      "stopSequences": { "openai": "stop", "anthropic": "stop_sequences" },
+      "allowMultipleToolCalls": { "openai": "parallel_tool_calls" },
+    };
+    for (const [key, value] of Object.entries(data)) {
+      const mapping = wireMap[key];
+      if (mapping?.[provider]) {
+        result[mapping[provider]] = value;
+      }
+    }
     return result;
   }
 
-  /**
-   * Convert the ModelOptions instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the ModelOptions instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a ModelOptions instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ModelOptions instance.
-   */
   static fromJson(json: string, context?: LoadContext): ModelOptions {
     const data = JSON.parse(json);
-
     return ModelOptions.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a ModelOptions instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ModelOptions instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): ModelOptions {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return ModelOptions.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/model.ts b/runtime/typescript/packages/core/src/model/model.ts
index adc7dba3..e87f268e 100644
--- a/runtime/typescript/packages/core/src/model/model.ts
+++ b/runtime/typescript/packages/core/src/model/model.ts
@@ -5,61 +5,26 @@ import { LoadContext, SaveContext } from "./context";
 import { Connection } from "./connection";
 import { ModelOptions } from "./model-options";
 
-/**
- * Model for defining the structure and behavior of AI agents.
- * This model includes properties for specifying the model's provider, connection details, and various options.
- * It allows for flexible configuration of AI models to suit different use cases and requirements.
- *
- */
 export class Model {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = "id";
 
-  /**
-   * The unique identifier of the model - can be used as the single property shorthand
-   */
   id: string = "";
-
-  /**
-   * The provider of the model (e.g., 'openai', 'foundry', 'anthropic')
-   */
   provider?: string | undefined;
-
-  /**
-   * The type of API to use for the model (e.g., 'chat', 'response', etc.)
-   */
   apiType?: string | undefined;
-
-  /**
-   * The connection configuration for the model
-   */
   connection?: Connection | undefined;
-
-  /**
-   * Additional options for the model
-   */
   options?: ModelOptions | undefined;
 
-  /**
-   * Initializes a new instance of Model.
-   */
   constructor(init?: Partial<Model>) {
     this.id = init?.id ?? "";
-
     if (init?.provider !== undefined) {
       this.provider = init.provider;
     }
-
     if (init?.apiType !== undefined) {
       this.apiType = init.apiType;
     }
-
     if (init?.connection !== undefined) {
       this.connection = init.connection;
     }
-
     if (init?.options !== undefined) {
       this.options = init.options;
     }
@@ -67,51 +32,37 @@ export class Model {
 
   //#region Load Methods
 
-  /**
-   * Load a Model instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Model instance.
-   */
   static load(data: Record<string, unknown>, context?: LoadContext): Model {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
     // Handle alternate representations
     if (typeof data === "string") {
-      data = { id: data };
-    } else if (typeof data === "number") {
-    } else if (typeof data === "boolean") {
+      const instance = new Model();
+      instance.id = data as string;
+      if (context) {
+        return context.processOutput(instance) as Model;
+      }
+      return instance;
     }
 
-    // Create new instance
     const instance = new Model();
 
     if (data["id"] !== undefined && data["id"] !== null) {
       instance.id = String(data["id"]);
     }
-
     if (data["provider"] !== undefined && data["provider"] !== null) {
       instance.provider = String(data["provider"]);
     }
-
     if (data["apiType"] !== undefined && data["apiType"] !== null) {
       instance.apiType = String(data["apiType"]);
     }
-
     if (data["connection"] !== undefined && data["connection"] !== null) {
-      instance.connection = Connection.load(
-        data["connection"] as Record<string, unknown>,
-        context,
-      );
+      instance.connection = Connection.load(data["connection"] as Record<string, unknown>, context);
     }
-
     if (data["options"] !== undefined && data["options"] !== null) {
-      instance.options = ModelOptions.load(
-        data["options"] as Record<string, unknown>,
-        context,
-      );
+      instance.options = ModelOptions.load(data["options"] as Record<string, unknown>, context);
     }
 
     if (context) {
@@ -124,118 +75,57 @@ export class Model {
 
   //#region Save Methods
 
-  /**
-   * Save the Model instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as Model) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.id !== undefined && obj.id !== null) {
       result["id"] = obj.id;
     }
-
     if (obj.provider !== undefined && obj.provider !== null) {
       result["provider"] = obj.provider;
     }
-
     if (obj.apiType !== undefined && obj.apiType !== null) {
       result["apiType"] = obj.apiType;
     }
-
     if (obj.connection !== undefined && obj.connection !== null) {
-      result["connection"] = obj.connection?.save(context);
+      result["connection"] = obj.connection.save(context);
     }
-
     if (obj.options !== undefined && obj.options !== null) {
-      result["options"] = obj.options?.save(context);
+      result["options"] = obj.options.save(context);
     }
 
     if (context) {
       return context.processDict(result);
     }
-
     return result;
   }
 
-  /**
-   * Convert the Model instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the Model instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a Model instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Model instance.
-   */
   static fromJson(json: string, context?: LoadContext): Model {
     const data = JSON.parse(json);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return Model.load({ id: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return Model.load({ id: data }, context);
-    }
-
     return Model.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a Model instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Model instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): Model {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return Model.load({ id: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return Model.load({ id: data }, context);
-    }
-
     return Model.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/parser-config.ts b/runtime/typescript/packages/core/src/model/parser-config.ts
index 6a4a7154..44df1848 100644
--- a/runtime/typescript/packages/core/src/model/parser-config.ts
+++ b/runtime/typescript/packages/core/src/model/parser-config.ts
@@ -3,32 +3,14 @@
 
 import { LoadContext, SaveContext } from "./context";
 
-/**
- * Template parser definition
- *
- */
 export class ParserConfig {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = "kind";
 
-  /**
-   * Parser used to process the rendered template into API-compatible format
-   */
   kind: string = "*";
+  options?: Record<string, unknown> | undefined;
 
-  /**
-   * Options for the parser
-   */
-  options?: Record<string, unknown> | undefined = {};
-
-  /**
-   * Initializes a new instance of ParserConfig.
-   */
   constructor(init?: Partial<ParserConfig>) {
     this.kind = init?.kind ?? "*";
-
     if (init?.options !== undefined) {
       this.options = init.options;
     }
@@ -36,34 +18,26 @@ export class ParserConfig {
 
   //#region Load Methods
 
-  /**
-   * Load a ParserConfig instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ParserConfig instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): ParserConfig {
+  static load(data: Record<string, unknown>, context?: LoadContext): ParserConfig {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
     // Handle alternate representations
     if (typeof data === "string") {
-      data = { kind: data };
-    } else if (typeof data === "number") {
-    } else if (typeof data === "boolean") {
+      const instance = new ParserConfig();
+      instance.kind = data as string;
+      if (context) {
+        return context.processOutput(instance) as ParserConfig;
+      }
+      return instance;
     }
 
-    // Create new instance
     const instance = new ParserConfig();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["options"] !== undefined && data["options"] !== null) {
       instance.options = data["options"] as Record<string, unknown>;
     }
@@ -78,20 +52,17 @@ export class ParserConfig {
 
   //#region Save Methods
 
-  /**
-   * Save the ParserConfig instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as ParserConfig) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.options !== undefined && obj.options !== null) {
       result["options"] = obj.options;
     }
@@ -99,85 +70,30 @@ export class ParserConfig {
     if (context) {
       return context.processDict(result);
     }
-
     return result;
   }
 
-  /**
-   * Convert the ParserConfig instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the ParserConfig instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a ParserConfig instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ParserConfig instance.
-   */
   static fromJson(json: string, context?: LoadContext): ParserConfig {
     const data = JSON.parse(json);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return ParserConfig.load({ kind: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return ParserConfig.load({ kind: data }, context);
-    }
-
     return ParserConfig.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a ParserConfig instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ParserConfig instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): ParserConfig {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return ParserConfig.load({ kind: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-        } else {
-        }
-      } else if (typeof data === "boolean") {
-      }
-      // Fallback - shouldn't reach here
-      return ParserConfig.load({ kind: data }, context);
-    }
-
     return ParserConfig.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/parser.ts b/runtime/typescript/packages/core/src/model/parser.ts
new file mode 100644
index 00000000..ee32c2ed
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/parser.ts
@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { Message } from "./message";
+import { Prompty } from "./prompty";
+
+/** Parses rendered prompt text into an array of structured messages with role markers. */
+export interface Parser {
+  /** Pre-process a template before rendering, returning modified template and context */
+  preRender?(template: string): unknown | null;
+  /** Parse rendered text into a structured message array */
+  parse(agent: Prompty, rendered: string, context: Record<string, unknown> | null): Promise<Message[]>;
+}
+
diff --git a/runtime/typescript/packages/core/src/model/processor.ts b/runtime/typescript/packages/core/src/model/processor.ts
new file mode 100644
index 00000000..949ffa19
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/processor.ts
@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { Prompty } from "./prompty";
+
+/** Extracts a clean, typed result from a raw LLM provider response. */
+export interface Processor {
+  /** Extract a clean result from a raw LLM response */
+  process(agent: Prompty, response: unknown): Promise<unknown>;
+  /** Process a streaming response into a stream of StreamChunk items. Takes raw chunks from the executor and yields processed text, thinking, tool, or error chunks. Not all providers support streaming; the default implementation should signal lack of support. */
+  processStream?(stream: unknown): Promise<unknown>;
+}
+
diff --git a/runtime/typescript/packages/core/src/model/prompty.ts b/runtime/typescript/packages/core/src/model/prompty.ts
index f8d4254a..3a3a40ed 100644
--- a/runtime/typescript/packages/core/src/model/prompty.ts
+++ b/runtime/typescript/packages/core/src/model/prompty.ts
@@ -7,107 +7,46 @@ import { Property } from "./property";
 import { Template } from "./template";
 import { Tool } from "./tool";
 
-/**
- * A Prompty is a markdown file format for LLM prompts. The frontmatter defines
- * structured metadata including model configuration, input/output schemas, tools,
- * and template settings. The markdown body becomes the instructions.
- *
- * This is the single root type for the Prompty schema — there is no abstract base
- * class or kind discriminator. A .prompty file always produces a Prompty instance.
- *
- */
 export class Prompty {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * Human-readable name of the prompt
-   */
   name: string = "";
-
-  /**
-   * Display name for UI purposes
-   */
   displayName?: string | undefined;
-
-  /**
-   * Description of the prompt's purpose
-   */
   description?: string | undefined;
-
-  /**
-   * Additional metadata including authors, tags, and other arbitrary properties
-   */
-  metadata?: Record<string, unknown> | undefined = {};
-
-  /**
-   * Input parameters that participate in template rendering
-   */
+  metadata?: Record<string, unknown> | undefined;
   inputs?: Property[] = [];
-
-  /**
-   * Expected output format and structure
-   */
   outputs?: Property[] = [];
-
-  /**
-   * AI model configuration
-   */
-  model: Model;
-
-  /**
-   * Tools available for extended functionality
-   */
+  model!: Model;
   tools?: Tool[] = [];
-
-  /**
-   * Template configuration for prompt rendering
-   */
   template?: Template | undefined;
-
-  /**
-   * Clear directions on what the prompt should do. In .prompty files, this comes from the markdown body.
-   */
   instructions?: string | undefined;
 
-  /**
-   * Initializes a new instance of Prompty.
-   */
   constructor(init?: Partial<Prompty>) {
     this.name = init?.name ?? "";
-
     if (init?.displayName !== undefined) {
       this.displayName = init.displayName;
     }
-
     if (init?.description !== undefined) {
       this.description = init.description;
     }
-
     if (init?.metadata !== undefined) {
       this.metadata = init.metadata;
     }
-
     if (init?.inputs !== undefined) {
       this.inputs = init.inputs;
     }
-
     if (init?.outputs !== undefined) {
       this.outputs = init.outputs;
     }
-
-    this.model = init?.model ?? undefined!;
-
+    if (init?.model !== undefined) {
+      this.model = init.model;
+    }
     if (init?.tools !== undefined) {
       this.tools = init.tools;
     }
-
     if (init?.template !== undefined) {
       this.template = init.template;
     }
-
     if (init?.instructions !== undefined) {
       this.instructions = init.instructions;
     }
@@ -115,62 +54,40 @@ export class Prompty {
 
   //#region Load Methods
 
-  /**
-   * Load a Prompty instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Prompty instance.
-   */
   static load(data: Record<string, unknown>, context?: LoadContext): Prompty {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new Prompty();
 
     if (data["name"] !== undefined && data["name"] !== null) {
       instance.name = String(data["name"]);
     }
-
     if (data["displayName"] !== undefined && data["displayName"] !== null) {
       instance.displayName = String(data["displayName"]);
     }
-
     if (data["description"] !== undefined && data["description"] !== null) {
       instance.description = String(data["description"]);
     }
-
     if (data["metadata"] !== undefined && data["metadata"] !== null) {
       instance.metadata = data["metadata"] as Record<string, unknown>;
     }
-
     if (data["inputs"] !== undefined && data["inputs"] !== null) {
-      instance.inputs = Prompty.loadInputs(data["inputs"], context);
+      instance.inputs = Prompty.loadInputs(data["inputs"] as unknown[], context);
     }
-
     if (data["outputs"] !== undefined && data["outputs"] !== null) {
-      instance.outputs = Prompty.loadOutputs(data["outputs"], context);
+      instance.outputs = Prompty.loadOutputs(data["outputs"] as unknown[], context);
     }
-
     if (data["model"] !== undefined && data["model"] !== null) {
-      instance.model = Model.load(
-        data["model"] as Record<string, unknown>,
-        context,
-      );
+      instance.model = Model.load(data["model"] as Record<string, unknown>, context);
     }
-
     if (data["tools"] !== undefined && data["tools"] !== null) {
-      instance.tools = Prompty.loadTools(data["tools"], context);
+      instance.tools = Prompty.loadTools(data["tools"] as unknown[], context);
     }
-
     if (data["template"] !== undefined && data["template"] !== null) {
-      instance.template = Template.load(
-        data["template"] as Record<string, unknown>,
-        context,
-      );
+      instance.template = Template.load(data["template"] as Record<string, unknown>, context);
     }
-
     if (data["instructions"] !== undefined && data["instructions"] !== null) {
       instance.instructions = String(data["instructions"]);
     }
@@ -181,132 +98,128 @@ export class Prompty {
     return instance;
   }
 
-  /**
-   * Load a collection of Property from a dictionary or array.
-   * @param data - The data to load from.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded array of Property.
-   */
-  static loadInputs(data: unknown, context?: LoadContext): Property[] {
-    const result: Property[] = [];
-
-    if (data && typeof data === "object" && !Array.isArray(data)) {
-      // Convert named dictionary to array
-      for (const [key, value] of Object.entries(
-        data as Record<string, unknown>,
-      )) {
-        if (Array.isArray(value)) {
-          throw new Error(
-            `Invalid 'inputs' format: key '${key}' has an array value. ` +
-              `'inputs' must be a flat list of objects or a name-keyed dict — ` +
-              `not a nested { ${key}: [...] } structure.`,
-          );
-        }
-        if (value && typeof value === "object") {
-          // Value is an object, add name to it
-          (value as Record<string, unknown>)["name"] = key;
-          result.push(Property.load(value as Record<string, unknown>, context));
+  static loadInputs(data: Record<string, unknown>[] | unknown[], context?: LoadContext): Property[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
         } else {
-          // Value is a scalar — let Property.load() infer kind from value
-          const prop = Property.load(value as Record<string, unknown>, context);
-          prop.name = key;
-          result.push(prop);
+          result.push({ name: k, "kind": v });
         }
       }
-    } else if (Array.isArray(data)) {
-      for (const item of data) {
-        if (item && typeof item === "object") {
-          result.push(Property.load(item as Record<string, unknown>, context));
+      data = result;
+    }
+    return data.map(item => Property.load(item as Record<string, unknown>, context));
+  }
+
+  static saveInputs(items: Property[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    if (context.collectionFormat === "array") {
+      return items.map(item => item.save(context));
+    }
+
+    // Object format: use name as key
+    const result: Record<string, unknown> = {};
+    for (const item of items) {
+      const itemData = item.save(context) as Record<string, unknown>;
+      const name = itemData["name"] as string | undefined;
+      delete itemData["name"];
+      if (name) {
+        // Check if we can use shorthand (only primary property set)
+        const shorthand = (item.constructor as typeof Property).shorthandProperty;
+        if (context.useShorthand && shorthand && Object.keys(itemData).length === 1 && shorthand in itemData) {
+          result[name] = itemData[shorthand];
+          continue;
+        }
+        result[name] = itemData;
+      } else {
+        // No name, fall back to array format for this item
+        if (!result["_unnamed"]) {
+          result["_unnamed"] = [];
         }
+        (result["_unnamed"] as unknown[]).push(itemData);
       }
     }
-
     return result;
   }
 
-  /**
-   * Load a collection of Property from a dictionary or array.
-   * @param data - The data to load from.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded array of Property.
-   */
-  static loadOutputs(data: unknown, context?: LoadContext): Property[] {
-    const result: Property[] = [];
-
-    if (data && typeof data === "object" && !Array.isArray(data)) {
-      // Convert named dictionary to array
-      for (const [key, value] of Object.entries(
-        data as Record<string, unknown>,
-      )) {
-        if (Array.isArray(value)) {
-          throw new Error(
-            `Invalid 'outputs' format: key '${key}' has an array value. ` +
-              `'outputs' must be a flat list of objects or a name-keyed dict — ` +
-              `not a nested { ${key}: [...] } structure.`,
-          );
-        }
-        if (value && typeof value === "object") {
-          // Value is an object, add name to it
-          (value as Record<string, unknown>)["name"] = key;
-          result.push(Property.load(value as Record<string, unknown>, context));
+  static loadOutputs(data: Record<string, unknown>[] | unknown[], context?: LoadContext): Property[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
         } else {
-          // Value is a scalar — let Property.load() infer kind from value
-          const prop = Property.load(value as Record<string, unknown>, context);
-          prop.name = key;
-          result.push(prop);
-        }
-      }
-    } else if (Array.isArray(data)) {
-      for (const item of data) {
-        if (item && typeof item === "object") {
-          result.push(Property.load(item as Record<string, unknown>, context));
+          result.push({ name: k, "kind": v });
         }
       }
+      data = result;
     }
+    return data.map(item => Property.load(item as Record<string, unknown>, context));
+  }
 
-    return result;
+  static saveOutputs(items: Property[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    // This type doesn't have a 'name' property, so always use array format
+    return items.map(item => item.save(context));
   }
 
-  /**
-   * Load a collection of Tool from a dictionary or array.
-   * @param data - The data to load from.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded array of Tool.
-   */
-  static loadTools(data: unknown, context?: LoadContext): Tool[] {
-    const result: Tool[] = [];
-
-    if (data && typeof data === "object" && !Array.isArray(data)) {
-      // Convert named dictionary to array
-      for (const [key, value] of Object.entries(
-        data as Record<string, unknown>,
-      )) {
-        if (Array.isArray(value)) {
-          throw new Error(
-            `Invalid 'tools' format: key '${key}' has an array value. ` +
-              `'tools' must be a flat list of objects or a name-keyed dict — ` +
-              `not a nested { ${key}: [...] } structure.`,
-          );
-        }
-        if (value && typeof value === "object") {
-          // Value is an object, add name to it
-          (value as Record<string, unknown>)["name"] = key;
-          result.push(Tool.load(value as Record<string, unknown>, context));
+  static loadTools(data: Record<string, unknown>[] | unknown[], context?: LoadContext): Tool[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
         } else {
-          // Value is a scalar — let Tool.load() infer kind from value
-          const prop = Tool.load(value as Record<string, unknown>, context);
-          prop.name = key;
-          result.push(prop);
+          result.push({ name: k, "kind": v });
         }
       }
-    } else if (Array.isArray(data)) {
-      for (const item of data) {
-        if (item && typeof item === "object") {
-          result.push(Tool.load(item as Record<string, unknown>, context));
+      data = result;
+    }
+    return data.map(item => Tool.load(item as Record<string, unknown>, context));
+  }
+
+  static saveTools(items: Tool[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    if (context.collectionFormat === "array") {
+      return items.map(item => item.save(context));
+    }
+
+    // Object format: use name as key
+    const result: Record<string, unknown> = {};
+    for (const item of items) {
+      const itemData = item.save(context) as Record<string, unknown>;
+      const name = itemData["name"] as string | undefined;
+      delete itemData["name"];
+      if (name) {
+        // Check if we can use shorthand (only primary property set)
+        const shorthand = (item.constructor as typeof Tool).shorthandProperty;
+        if (context.useShorthand && shorthand && Object.keys(itemData).length === 1 && shorthand in itemData) {
+          result[name] = itemData[shorthand];
+          continue;
         }
+        result[name] = itemData;
+      } else {
+        // No name, fall back to array format for this item
+        if (!result["_unnamed"]) {
+          result["_unnamed"] = [];
+        }
+        (result["_unnamed"] as unknown[]).push(itemData);
       }
     }
-
     return result;
   }
 
@@ -314,52 +227,41 @@ export class Prompty {
 
   //#region Save Methods
 
-  /**
-   * Save the Prompty instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as Prompty) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.name !== undefined && obj.name !== null) {
       result["name"] = obj.name;
     }
-
     if (obj.displayName !== undefined && obj.displayName !== null) {
       result["displayName"] = obj.displayName;
     }
-
     if (obj.description !== undefined && obj.description !== null) {
       result["description"] = obj.description;
     }
-
     if (obj.metadata !== undefined && obj.metadata !== null) {
       result["metadata"] = obj.metadata;
     }
-
     if (obj.inputs !== undefined && obj.inputs !== null) {
       result["inputs"] = Prompty.saveInputs(obj.inputs, context);
     }
-
     if (obj.outputs !== undefined && obj.outputs !== null) {
       result["outputs"] = Prompty.saveOutputs(obj.outputs, context);
     }
-
     if (obj.model !== undefined && obj.model !== null) {
-      result["model"] = obj.model?.save(context);
+      result["model"] = obj.model.save(context);
     }
-
     if (obj.tools !== undefined && obj.tools !== null) {
       result["tools"] = Prompty.saveTools(obj.tools, context);
     }
-
     if (obj.template !== undefined && obj.template !== null) {
-      result["template"] = obj.template?.save(context);
+      result["template"] = obj.template.save(context);
     }
-
     if (obj.instructions !== undefined && obj.instructions !== null) {
       result["instructions"] = obj.instructions;
     }
@@ -367,157 +269,30 @@ export class Prompty {
     if (context) {
       return context.processDict(result);
     }
-
-    return result;
-  }
-
-  /**
-   * Save a collection of Property to object or array format.
-   * @param items - The items to save.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The saved collection in object or array format.
-   */
-  static saveInputs(
-    items: Property[],
-    context?: SaveContext,
-  ): Record<string, unknown> | Record<string, unknown>[] {
-    context = context ?? new SaveContext();
-
-    if (context.collectionFormat === "array") {
-      return items.map((item) => item.save(context));
-    }
-
-    // Object format: use name as key
-    const result: Record<string, unknown> = {};
-    for (const item of items) {
-      const itemData = item.save(context);
-      const name = itemData["name"] as string | undefined;
-      if (name) {
-        delete itemData["name"];
-
-        // Check if we can use shorthand
-        if (context.useShorthand && Property.shorthandProperty) {
-          const shorthandProp = Property.shorthandProperty;
-          const keys = Object.keys(itemData);
-          if (keys.length === 1 && keys[0] === shorthandProp) {
-            result[name] = itemData[shorthandProp];
-            continue;
-          }
-        }
-        result[name] = itemData;
-      } else {
-        throw new Error(
-          "Cannot save item in object format: missing 'name' property",
-        );
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Save a collection of Property to object or array format.
-   * @param items - The items to save.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The saved collection in object or array format.
-   */
-  static saveOutputs(
-    items: Property[],
-    context?: SaveContext,
-  ): Record<string, unknown> | Record<string, unknown>[] {
-    context = context ?? new SaveContext();
-
-    // This type doesn't have a 'name' property, so always use array format
-    return items.map((item) => item.save(context));
-  }
-
-  /**
-   * Save a collection of Tool to object or array format.
-   * @param items - The items to save.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The saved collection in object or array format.
-   */
-  static saveTools(
-    items: Tool[],
-    context?: SaveContext,
-  ): Record<string, unknown> | Record<string, unknown>[] {
-    context = context ?? new SaveContext();
-
-    if (context.collectionFormat === "array") {
-      return items.map((item) => item.save(context));
-    }
-
-    // Object format: use name as key
-    const result: Record<string, unknown> = {};
-    for (const item of items) {
-      const itemData = item.save(context);
-      const name = itemData["name"] as string | undefined;
-      if (name) {
-        delete itemData["name"];
-
-        // Check if we can use shorthand
-        if (context.useShorthand && Tool.shorthandProperty) {
-          const shorthandProp = Tool.shorthandProperty;
-          const keys = Object.keys(itemData);
-          if (keys.length === 1 && keys[0] === shorthandProp) {
-            result[name] = itemData[shorthandProp];
-            continue;
-          }
-        }
-        result[name] = itemData;
-      } else {
-        throw new Error(
-          "Cannot save item in object format: missing 'name' property",
-        );
-      }
-    }
     return result;
   }
 
-  /**
-   * Convert the Prompty instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the Prompty instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a Prompty instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Prompty instance.
-   */
   static fromJson(json: string, context?: LoadContext): Prompty {
     const data = JSON.parse(json);
-
     return Prompty.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a Prompty instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Prompty instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): Prompty {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return Prompty.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/property.ts b/runtime/typescript/packages/core/src/model/property.ts
index e6fa3357..93335b26 100644
--- a/runtime/typescript/packages/core/src/model/property.ts
+++ b/runtime/typescript/packages/core/src/model/property.ts
@@ -3,80 +3,32 @@
 
 import { LoadContext, SaveContext } from "./context";
 
-/**
- * Represents a single property.
- *
- * - This model defines the structure of properties that can be used in prompts,
- * including their type, description, whether they are required, and other attributes.
- * - It allows for the definition of dynamic inputs that can be filled with data
- * and processed to generate prompts for AI models.
- *
- */
 export class Property {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = "example";
 
-  /**
-   * Name of the property
-   */
   name: string = "";
-
-  /**
-   * The data type of the input property
-   */
   kind: string = "";
-
-  /**
-   * A short description of the input property
-   */
   description?: string | undefined;
-
-  /**
-   * Whether the property is required
-   */
   required?: boolean | undefined;
-
-  /**
-   * The default value of the property - this represents the default value if none is provided
-   */
   default?: unknown | undefined;
-
-  /**
-   * Example value used for either initialization or tooling
-   */
   example?: unknown | undefined;
-
-  /**
-   * Allowed enumeration values for the property
-   */
   enumValues?: unknown[] = [];
 
-  /**
-   * Initializes a new instance of Property.
-   */
   constructor(init?: Partial<Property>) {
     this.name = init?.name ?? "";
-
     this.kind = init?.kind ?? "";
-
     if (init?.description !== undefined) {
       this.description = init.description;
     }
-
     if (init?.required !== undefined) {
       this.required = init.required;
     }
-
     if (init?.default !== undefined) {
       this.default = init.default;
     }
-
     if (init?.example !== undefined) {
       this.example = init.example;
     }
-
     if (init?.enumValues !== undefined) {
       this.enumValues = init.enumValues;
     }
@@ -84,35 +36,48 @@ export class Property {
 
   //#region Load Methods
 
-  /**
-   * Load a Property instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Property instance.
-   */
   static load(data: Record<string, unknown>, context?: LoadContext): Property {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
     // Handle alternate representations
-    if (typeof data === "string") {
-      data = { kind: "string", example: data };
-    } else if (typeof data === "number") {
-      // Check if it's an integer or float
-      if (Number.isInteger(data)) {
-        data = { kind: "integer", example: data };
-      } else {
-        data = { kind: "float", example: data };
+    if (typeof data === "boolean") {
+      const instance = new Property();
+      instance.kind = "boolean";
+      instance.example = data as boolean;
+      if (context) {
+        return context.processOutput(instance) as Property;
       }
-      // Check if it's an integer or float
+      return instance;
+    }
+    if (typeof data === "number") {
       if (Number.isInteger(data)) {
-        data = { kind: "integer", example: data };
+        const instance = new Property();
+        instance.kind = "integer";
+        instance.example = data as number;
+        if (context) {
+          return context.processOutput(instance) as Property;
+        }
+        return instance;
       } else {
-        data = { kind: "float", example: data };
+        const instance = new Property();
+        instance.kind = "float";
+        instance.example = data as number;
+        if (context) {
+          return context.processOutput(instance) as Property;
+        }
+        return instance;
       }
-    } else if (typeof data === "boolean") {
-      data = { kind: "boolean", example: data };
+    }
+    if (typeof data === "string") {
+      const instance = new Property();
+      instance.kind = "string";
+      instance.example = data as string;
+      if (context) {
+        return context.processOutput(instance) as Property;
+      }
+      return instance;
     }
 
     // Load polymorphic Property instance
@@ -121,31 +86,23 @@ export class Property {
     if (data["name"] !== undefined && data["name"] !== null) {
       instance.name = String(data["name"]);
     }
-
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["description"] !== undefined && data["description"] !== null) {
       instance.description = String(data["description"]);
     }
-
     if (data["required"] !== undefined && data["required"] !== null) {
       instance.required = Boolean(data["required"]);
     }
-
     if (data["default"] !== undefined && data["default"] !== null) {
       instance.default = data["default"] as unknown;
     }
-
     if (data["example"] !== undefined && data["example"] !== null) {
       instance.example = data["example"] as unknown;
     }
-
     if (data["enumValues"] !== undefined && data["enumValues"] !== null) {
-      instance.enumValues = Array.isArray(data["enumValues"])
-        ? (data["enumValues"] as unknown[]).map((v) => String(v))
-        : [];
+      instance.enumValues = data["enumValues"] as unknown[];
     }
 
     if (context) {
@@ -154,16 +111,7 @@ export class Property {
     return instance;
   }
 
-  /**
-   * Load polymorphic Property based on discriminator.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Property instance.
-   */
-  private static loadKind(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): Property {
+  private static loadKind(data: Record<string, unknown>, context?: LoadContext): Property {
     const discriminatorValue = data["kind"];
     if (discriminatorValue !== undefined && discriminatorValue !== null) {
       const discriminator = String(discriminatorValue).toLowerCase();
@@ -176,7 +124,6 @@ export class Property {
           return new Property();
       }
     }
-
     return new Property();
   }
 
@@ -184,40 +131,32 @@ export class Property {
 
   //#region Save Methods
 
-  /**
-   * Save the Property instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as Property) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.name !== undefined && obj.name !== null) {
       result["name"] = obj.name;
     }
-
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.description !== undefined && obj.description !== null) {
       result["description"] = obj.description;
     }
-
     if (obj.required !== undefined && obj.required !== null) {
       result["required"] = obj.required;
     }
-
     if (obj.default !== undefined && obj.default !== null) {
       result["default"] = obj.default;
     }
-
     if (obj.example !== undefined && obj.example !== null) {
       result["example"] = obj.example;
     }
-
     if (obj.enumValues !== undefined && obj.enumValues !== null) {
       result["enumValues"] = obj.enumValues;
     }
@@ -225,155 +164,61 @@ export class Property {
     if (context) {
       return context.processDict(result);
     }
-
     return result;
   }
 
-  /**
-   * Convert the Property instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the Property instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a Property instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Property instance.
-   */
   static fromJson(json: string, context?: LoadContext): Property {
     const data = JSON.parse(json);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return Property.load({ kind: "string", example: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-          return Property.load({ kind: "integer", example: data }, context);
-        } else {
-          return Property.load({ kind: "float", example: data }, context);
-        }
-      } else if (typeof data === "boolean") {
-        return Property.load({ kind: "boolean", example: data }, context);
-      }
-      // Fallback - shouldn't reach here
-      return Property.load({ kind: "boolean", example: data }, context);
-    }
-
     return Property.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a Property instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Property instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): Property {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        return Property.load({ kind: "string", example: data }, context);
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-          return Property.load({ kind: "integer", example: data }, context);
-        } else {
-          return Property.load({ kind: "float", example: data }, context);
-        }
-      } else if (typeof data === "boolean") {
-        return Property.load({ kind: "boolean", example: data }, context);
-      }
-      // Fallback - shouldn't reach here
-      return Property.load({ kind: "boolean", example: data }, context);
-    }
-
     return Property.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * Represents an array property.
- * This extends the base Property model to represent an array of items.
- *
- */
 export class ArrayProperty extends Property {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   *
-   */
   kind: string = "array";
+  items!: Property;
 
-  /**
-   * The type of items contained in the array
-   */
-  items: Property;
-
-  /**
-   * Initializes a new instance of ArrayProperty.
-   */
   constructor(init?: Partial<ArrayProperty>) {
     super(init);
-
     this.kind = init?.kind ?? "array";
-
-    this.items = init?.items ?? undefined!;
+    if (init?.items !== undefined) {
+      this.items = init.items;
+    }
   }
 
   //#region Load Methods
 
-  /**
-   * Load a ArrayProperty instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ArrayProperty instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): ArrayProperty {
+  static load(data: Record<string, unknown>, context?: LoadContext): ArrayProperty {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new ArrayProperty();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["items"] !== undefined && data["items"] !== null) {
-      instance.items = Property.load(
-        data["items"] as Record<string, unknown>,
-        context,
-      );
+      instance.items = Property.load(data["items"] as Record<string, unknown>, context);
     }
 
     if (context) {
@@ -386,13 +231,11 @@ export class ArrayProperty extends Property {
 
   //#region Save Methods
 
-  /**
-   * Save the ArrayProperty instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as ArrayProperty) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -400,123 +243,62 @@ export class ArrayProperty extends Property {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.items !== undefined && obj.items !== null) {
-      result["items"] = obj.items?.save(context);
+      result["items"] = obj.items.save(context);
     }
-
     return result;
   }
 
-  /**
-   * Convert the ArrayProperty instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the ArrayProperty instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a ArrayProperty instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ArrayProperty instance.
-   */
   static fromJson(json: string, context?: LoadContext): ArrayProperty {
     const data = JSON.parse(json);
-
     return ArrayProperty.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a ArrayProperty instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ArrayProperty instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): ArrayProperty {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return ArrayProperty.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * Represents an object property.
- * This extends the base Property model to represent a structured object.
- *
- */
 export class ObjectProperty extends Property {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   *
-   */
   kind: string = "object";
-
-  /**
-   * The properties contained in the object
-   */
   properties: Property[] = [];
 
-  /**
-   * Initializes a new instance of ObjectProperty.
-   */
   constructor(init?: Partial<ObjectProperty>) {
     super(init);
-
     this.kind = init?.kind ?? "object";
-
     this.properties = init?.properties ?? [];
   }
 
   //#region Load Methods
 
-  /**
-   * Load a ObjectProperty instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ObjectProperty instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): ObjectProperty {
+  static load(data: Record<string, unknown>, context?: LoadContext): ObjectProperty {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new ObjectProperty();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["properties"] !== undefined && data["properties"] !== null) {
-      instance.properties = ObjectProperty.loadProperties(
-        data["properties"],
-        context,
-      );
+      instance.properties = ObjectProperty.loadProperties(data["properties"] as unknown[], context);
     }
 
     if (context) {
@@ -525,62 +307,40 @@ export class ObjectProperty extends Property {
     return instance;
   }
 
-  /**
-   * Load a collection of Property from a dictionary or array.
-   * @param data - The data to load from.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded array of Property.
-   */
-  static loadProperties(data: unknown, context?: LoadContext): Property[] {
-    const result: Property[] = [];
-
-    if (data && typeof data === "object" && !Array.isArray(data)) {
-      // Convert named dictionary to array
-      for (const [key, value] of Object.entries(
-        data as Record<string, unknown>,
-      )) {
-        if (Array.isArray(value)) {
-          throw new Error(
-            `Invalid 'properties' format: key '${key}' has an array value. ` +
-              `'properties' must be a flat list of objects or a name-keyed dict — ` +
-              `not a nested { ${key}: [...] } structure.`,
-          );
-        }
-        if (value && typeof value === "object") {
-          // Value is an object, add name to it
-          (value as Record<string, unknown>)["name"] = key;
-          result.push(Property.load(value as Record<string, unknown>, context));
+  static loadProperties(data: Record<string, unknown>[] | unknown[], context?: LoadContext): Property[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
         } else {
-          // Value is a scalar — let Property.load() infer kind from value
-          const prop = Property.load(value as Record<string, unknown>, context);
-          prop.name = key;
-          result.push(prop);
-        }
-      }
-    } else if (Array.isArray(data)) {
-      for (const item of data) {
-        if (item && typeof item === "object") {
-          result.push(Property.load(item as Record<string, unknown>, context));
+          result.push({ name: k, "kind": v });
         }
       }
+      data = result;
     }
+    return data.map(item => Property.load(item as Record<string, unknown>, context));
+  }
 
-    return result;
+  static saveProperties(items: Property[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    // This type doesn't have a 'name' property, so always use array format
+    return items.map(item => item.save(context));
   }
 
   //#endregion
 
   //#region Save Methods
 
-  /**
-   * Save the ObjectProperty instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context
-      ? (context.processObject(this) as ObjectProperty)
-      : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -588,78 +348,33 @@ export class ObjectProperty extends Property {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.properties !== undefined && obj.properties !== null) {
-      result["properties"] = ObjectProperty.saveProperties(
-        obj.properties,
-        context,
-      );
+      result["properties"] = ObjectProperty.saveProperties(obj.properties, context);
     }
-
     return result;
   }
 
-  /**
-   * Save a collection of Property to object or array format.
-   * @param items - The items to save.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The saved collection in object or array format.
-   */
-  static saveProperties(
-    items: Property[],
-    context?: SaveContext,
-  ): Record<string, unknown> | Record<string, unknown>[] {
-    context = context ?? new SaveContext();
-
-    // This type doesn't have a 'name' property, so always use array format
-    return items.map((item) => item.save(context));
-  }
-
-  /**
-   * Convert the ObjectProperty instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the ObjectProperty instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a ObjectProperty instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ObjectProperty instance.
-   */
   static fromJson(json: string, context?: LoadContext): ObjectProperty {
     const data = JSON.parse(json);
-
     return ObjectProperty.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a ObjectProperty instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded ObjectProperty instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): ObjectProperty {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return ObjectProperty.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/renderer.ts b/runtime/typescript/packages/core/src/model/renderer.ts
new file mode 100644
index 00000000..cbec0d2c
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/renderer.ts
@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { Prompty } from "./prompty";
+
+/** Renders a template string with input values to produce the final prompt text. */
+export interface Renderer {
+  /** Render the template string with input values */
+  render(agent: Prompty, template: string, inputs: Record<string, unknown>): Promise<string>;
+}
+
diff --git a/runtime/typescript/packages/core/src/model/status-event-payload.ts b/runtime/typescript/packages/core/src/model/status-event-payload.ts
new file mode 100644
index 00000000..5e126b25
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/status-event-payload.ts
@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class StatusEventPayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  message: string = "";
+
+  constructor(init?: Partial<StatusEventPayload>) {
+    this.message = init?.message ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): StatusEventPayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new StatusEventPayload();
+
+    if (data["message"] !== undefined && data["message"] !== null) {
+      instance.message = String(data["message"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as StatusEventPayload;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.message !== undefined && obj.message !== null) {
+      result["message"] = obj.message;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): StatusEventPayload {
+    const data = JSON.parse(json);
+    return StatusEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): StatusEventPayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return StatusEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/stream-chunk.ts b/runtime/typescript/packages/core/src/model/stream-chunk.ts
new file mode 100644
index 00000000..23a519ca
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/stream-chunk.ts
@@ -0,0 +1,423 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+import { ToolCall } from "./tool-call";
+
+export abstract class StreamChunk {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "";
+
+  constructor(init?: Partial<StreamChunk>) {
+    this.kind = init?.kind ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): StreamChunk {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    // Load polymorphic StreamChunk instance
+    const instance = StreamChunk.loadKind(data, context);
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as StreamChunk;
+    }
+    return instance;
+  }
+
+  private static loadKind(data: Record<string, unknown>, context?: LoadContext): StreamChunk {
+    const discriminatorValue = data["kind"];
+    if (discriminatorValue !== undefined && discriminatorValue !== null) {
+      const discriminator = String(discriminatorValue).toLowerCase();
+      switch (discriminator) {
+        case "text":
+          return TextChunk.load(data, context);
+        case "thinking":
+          return ThinkingChunk.load(data, context);
+        case "tool":
+          return ToolChunk.load(data, context);
+        case "error":
+          return ErrorChunk.load(data, context);
+        default:
+          throw new Error(`Unknown StreamChunk discriminator value: ${discriminator}`);
+      }
+    }
+    throw new Error("Missing StreamChunk discriminator property: 'kind'");
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): StreamChunk {
+    const data = JSON.parse(json);
+    return StreamChunk.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): StreamChunk {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return StreamChunk.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
+export class TextChunk extends StreamChunk {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "text";
+  value: string = "";
+
+  constructor(init?: Partial<TextChunk>) {
+    super(init);
+    this.kind = init?.kind ?? "text";
+    this.value = init?.value ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): TextChunk {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new TextChunk();
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+    if (data["value"] !== undefined && data["value"] !== null) {
+      instance.value = String(data["value"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as TextChunk;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    // Start with parent class properties
+    const result = super.save(context);
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+    if (obj.value !== undefined && obj.value !== null) {
+      result["value"] = obj.value;
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): TextChunk {
+    const data = JSON.parse(json);
+    return TextChunk.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): TextChunk {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return TextChunk.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
+export class ThinkingChunk extends StreamChunk {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "thinking";
+  value: string = "";
+
+  constructor(init?: Partial<ThinkingChunk>) {
+    super(init);
+    this.kind = init?.kind ?? "thinking";
+    this.value = init?.value ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ThinkingChunk {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ThinkingChunk();
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+    if (data["value"] !== undefined && data["value"] !== null) {
+      instance.value = String(data["value"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ThinkingChunk;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    // Start with parent class properties
+    const result = super.save(context);
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+    if (obj.value !== undefined && obj.value !== null) {
+      result["value"] = obj.value;
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ThinkingChunk {
+    const data = JSON.parse(json);
+    return ThinkingChunk.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ThinkingChunk {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ThinkingChunk.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
+export class ToolChunk extends StreamChunk {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "tool";
+  toolCall!: ToolCall;
+
+  constructor(init?: Partial<ToolChunk>) {
+    super(init);
+    this.kind = init?.kind ?? "tool";
+    if (init?.toolCall !== undefined) {
+      this.toolCall = init.toolCall;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ToolChunk {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ToolChunk();
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+    if (data["toolCall"] !== undefined && data["toolCall"] !== null) {
+      instance.toolCall = ToolCall.load(data["toolCall"] as Record<string, unknown>, context);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ToolChunk;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    // Start with parent class properties
+    const result = super.save(context);
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+    if (obj.toolCall !== undefined && obj.toolCall !== null) {
+      result["toolCall"] = obj.toolCall.save(context);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ToolChunk {
+    const data = JSON.parse(json);
+    return ToolChunk.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ToolChunk {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ToolChunk.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
+export class ErrorChunk extends StreamChunk {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  kind: string = "error";
+  message: string = "";
+
+  constructor(init?: Partial<ErrorChunk>) {
+    super(init);
+    this.kind = init?.kind ?? "error";
+    this.message = init?.message ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ErrorChunk {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ErrorChunk();
+
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+    if (data["message"] !== undefined && data["message"] !== null) {
+      instance.message = String(data["message"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ErrorChunk;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    // Start with parent class properties
+    const result = super.save(context);
+
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+    if (obj.message !== undefined && obj.message !== null) {
+      result["message"] = obj.message;
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ErrorChunk {
+    const data = JSON.parse(json);
+    return ErrorChunk.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ErrorChunk {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ErrorChunk.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/template.ts b/runtime/typescript/packages/core/src/model/template.ts
index 233851b8..60c2340f 100644
--- a/runtime/typescript/packages/core/src/model/template.ts
+++ b/runtime/typescript/packages/core/src/model/template.ts
@@ -5,70 +5,35 @@ import { LoadContext, SaveContext } from "./context";
 import { FormatConfig } from "./format-config";
 import { ParserConfig } from "./parser-config";
 
-/**
- * Template model for defining prompt templates.
- *
- * This model specifies the rendering engine used for slot filling prompts,
- * the parser used to process the rendered template into API-compatible format,
- * and additional options for the template engine.
- *
- * It allows for the creation of reusable templates that can be filled with dynamic data
- * and processed to generate prompts for AI models.
- *
- */
 export class Template {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * Template rendering engine used for slot filling prompts (e.g., mustache, jinja2)
-   */
-  format: FormatConfig;
+  format!: FormatConfig;
+  parser!: ParserConfig;
 
-  /**
-   * Parser used to process the rendered template into API-compatible format
-   */
-  parser: ParserConfig;
-
-  /**
-   * Initializes a new instance of Template.
-   */
   constructor(init?: Partial<Template>) {
-    this.format = init?.format ?? undefined!;
-
-    this.parser = init?.parser ?? undefined!;
+    if (init?.format !== undefined) {
+      this.format = init.format;
+    }
+    if (init?.parser !== undefined) {
+      this.parser = init.parser;
+    }
   }
 
   //#region Load Methods
 
-  /**
-   * Load a Template instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Template instance.
-   */
   static load(data: Record<string, unknown>, context?: LoadContext): Template {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new Template();
 
     if (data["format"] !== undefined && data["format"] !== null) {
-      instance.format = FormatConfig.load(
-        data["format"] as Record<string, unknown>,
-        context,
-      );
+      instance.format = FormatConfig.load(data["format"] as Record<string, unknown>, context);
     }
-
     if (data["parser"] !== undefined && data["parser"] !== null) {
-      instance.parser = ParserConfig.load(
-        data["parser"] as Record<string, unknown>,
-        context,
-      );
+      instance.parser = ParserConfig.load(data["parser"] as Record<string, unknown>, context);
     }
 
     if (context) {
@@ -81,76 +46,48 @@ export class Template {
 
   //#region Save Methods
 
-  /**
-   * Save the Template instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as Template) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.format !== undefined && obj.format !== null) {
-      result["format"] = obj.format?.save(context);
+      result["format"] = obj.format.save(context);
     }
-
     if (obj.parser !== undefined && obj.parser !== null) {
-      result["parser"] = obj.parser?.save(context);
+      result["parser"] = obj.parser.save(context);
     }
 
     if (context) {
       return context.processDict(result);
     }
-
     return result;
   }
 
-  /**
-   * Convert the Template instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the Template instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a Template instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Template instance.
-   */
   static fromJson(json: string, context?: LoadContext): Template {
     const data = JSON.parse(json);
-
     return Template.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a Template instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Template instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): Template {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return Template.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/thinking-event-payload.ts b/runtime/typescript/packages/core/src/model/thinking-event-payload.ts
new file mode 100644
index 00000000..ee35a020
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/thinking-event-payload.ts
@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class ThinkingEventPayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  token: string = "";
+
+  constructor(init?: Partial<ThinkingEventPayload>) {
+    this.token = init?.token ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ThinkingEventPayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ThinkingEventPayload();
+
+    if (data["token"] !== undefined && data["token"] !== null) {
+      instance.token = String(data["token"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ThinkingEventPayload;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.token !== undefined && obj.token !== null) {
+      result["token"] = obj.token;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ThinkingEventPayload {
+    const data = JSON.parse(json);
+    return ThinkingEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ThinkingEventPayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ThinkingEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/thread-marker.ts b/runtime/typescript/packages/core/src/model/thread-marker.ts
new file mode 100644
index 00000000..8e06660c
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/thread-marker.ts
@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class ThreadMarker {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  name: string = "thread";
+  kind: string = "thread";
+
+  constructor(init?: Partial<ThreadMarker>) {
+    this.name = init?.name ?? "thread";
+    this.kind = init?.kind ?? "thread";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ThreadMarker {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ThreadMarker();
+
+    if (data["name"] !== undefined && data["name"] !== null) {
+      instance.name = String(data["name"]);
+    }
+    if (data["kind"] !== undefined && data["kind"] !== null) {
+      instance.kind = String(data["kind"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ThreadMarker;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.name !== undefined && obj.name !== null) {
+      result["name"] = obj.name;
+    }
+    if (obj.kind !== undefined && obj.kind !== null) {
+      result["kind"] = obj.kind;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ThreadMarker {
+    const data = JSON.parse(json);
+    return ThreadMarker.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ThreadMarker {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ThreadMarker.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/token-event-payload.ts b/runtime/typescript/packages/core/src/model/token-event-payload.ts
new file mode 100644
index 00000000..4b2cc668
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/token-event-payload.ts
@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class TokenEventPayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  token: string = "";
+
+  constructor(init?: Partial<TokenEventPayload>) {
+    this.token = init?.token ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): TokenEventPayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new TokenEventPayload();
+
+    if (data["token"] !== undefined && data["token"] !== null) {
+      instance.token = String(data["token"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as TokenEventPayload;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.token !== undefined && obj.token !== null) {
+      result["token"] = obj.token;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): TokenEventPayload {
+    const data = JSON.parse(json);
+    return TokenEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): TokenEventPayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return TokenEventPayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/token-usage.ts b/runtime/typescript/packages/core/src/model/token-usage.ts
new file mode 100644
index 00000000..302df95b
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/token-usage.ts
@@ -0,0 +1,118 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class TokenUsage {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  promptTokens?: number | undefined;
+  completionTokens?: number | undefined;
+  totalTokens?: number | undefined;
+
+  constructor(init?: Partial<TokenUsage>) {
+    if (init?.promptTokens !== undefined) {
+      this.promptTokens = init.promptTokens;
+    }
+    if (init?.completionTokens !== undefined) {
+      this.completionTokens = init.completionTokens;
+    }
+    if (init?.totalTokens !== undefined) {
+      this.totalTokens = init.totalTokens;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): TokenUsage {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new TokenUsage();
+
+    if (data["promptTokens"] !== undefined && data["promptTokens"] !== null) {
+      instance.promptTokens = Number(data["promptTokens"]);
+    }
+    if (data["completionTokens"] !== undefined && data["completionTokens"] !== null) {
+      instance.completionTokens = Number(data["completionTokens"]);
+    }
+    if (data["totalTokens"] !== undefined && data["totalTokens"] !== null) {
+      instance.totalTokens = Number(data["totalTokens"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as TokenUsage;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.promptTokens !== undefined && obj.promptTokens !== null) {
+      result["promptTokens"] = obj.promptTokens;
+    }
+    if (obj.completionTokens !== undefined && obj.completionTokens !== null) {
+      result["completionTokens"] = obj.completionTokens;
+    }
+    if (obj.totalTokens !== undefined && obj.totalTokens !== null) {
+      result["totalTokens"] = obj.totalTokens;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toWire(provider: string): Record<string, unknown> {
+    const data = this.save();
+    const result: Record<string, unknown> = {};
+    const wireMap: Record<string, Record<string, string>> = {
+      "promptTokens": { "openai": "prompt_tokens", "anthropic": "input_tokens" },
+      "completionTokens": { "openai": "completion_tokens", "anthropic": "output_tokens" },
+      "totalTokens": { "openai": "total_tokens" },
+    };
+    for (const [key, value] of Object.entries(data)) {
+      const mapping = wireMap[key];
+      if (mapping?.[provider]) {
+        result[mapping[provider]] = value;
+      }
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): TokenUsage {
+    const data = JSON.parse(json);
+    return TokenUsage.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): TokenUsage {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return TokenUsage.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/tool-call-start-payload.ts b/runtime/typescript/packages/core/src/model/tool-call-start-payload.ts
new file mode 100644
index 00000000..fd21975a
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/tool-call-start-payload.ts
@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class ToolCallStartPayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  name: string = "";
+  arguments: string = "";
+
+  constructor(init?: Partial<ToolCallStartPayload>) {
+    this.name = init?.name ?? "";
+    this.arguments = init?.arguments ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ToolCallStartPayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ToolCallStartPayload();
+
+    if (data["name"] !== undefined && data["name"] !== null) {
+      instance.name = String(data["name"]);
+    }
+    if (data["arguments"] !== undefined && data["arguments"] !== null) {
+      instance.arguments = String(data["arguments"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ToolCallStartPayload;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.name !== undefined && obj.name !== null) {
+      result["name"] = obj.name;
+    }
+    if (obj.arguments !== undefined && obj.arguments !== null) {
+      result["arguments"] = obj.arguments;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ToolCallStartPayload {
+    const data = JSON.parse(json);
+    return ToolCallStartPayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ToolCallStartPayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ToolCallStartPayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/tool-call.ts b/runtime/typescript/packages/core/src/model/tool-call.ts
new file mode 100644
index 00000000..df3a61be
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/tool-call.ts
@@ -0,0 +1,95 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+
+export class ToolCall {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  id: string = "";
+  name: string = "";
+  arguments: string = "";
+
+  constructor(init?: Partial<ToolCall>) {
+    this.id = init?.id ?? "";
+    this.name = init?.name ?? "";
+    this.arguments = init?.arguments ?? "";
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ToolCall {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ToolCall();
+
+    if (data["id"] !== undefined && data["id"] !== null) {
+      instance.id = String(data["id"]);
+    }
+    if (data["name"] !== undefined && data["name"] !== null) {
+      instance.name = String(data["name"]);
+    }
+    if (data["arguments"] !== undefined && data["arguments"] !== null) {
+      instance.arguments = String(data["arguments"]);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ToolCall;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.id !== undefined && obj.id !== null) {
+      result["id"] = obj.id;
+    }
+    if (obj.name !== undefined && obj.name !== null) {
+      result["name"] = obj.name;
+    }
+    if (obj.arguments !== undefined && obj.arguments !== null) {
+      result["arguments"] = obj.arguments;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ToolCall {
+    const data = JSON.parse(json);
+    return ToolCall.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ToolCall {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ToolCall.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/tool-context.ts b/runtime/typescript/packages/core/src/model/tool-context.ts
new file mode 100644
index 00000000..77d4fdee
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/tool-context.ts
@@ -0,0 +1,115 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+import { Message } from "./message";
+
+export class ToolContext {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  messages: Message[] = [];
+  metadata?: Record<string, unknown> | undefined;
+
+  constructor(init?: Partial<ToolContext>) {
+    this.messages = init?.messages ?? [];
+    if (init?.metadata !== undefined) {
+      this.metadata = init.metadata;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ToolContext {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ToolContext();
+
+    if (data["messages"] !== undefined && data["messages"] !== null) {
+      instance.messages = ToolContext.loadMessages(data["messages"] as unknown[], context);
+    }
+    if (data["metadata"] !== undefined && data["metadata"] !== null) {
+      instance.metadata = data["metadata"] as Record<string, unknown>;
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ToolContext;
+    }
+    return instance;
+  }
+
+  static loadMessages(data: Record<string, unknown>[] | unknown[], context?: LoadContext): Message[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
+        } else {
+          result.push({ name: k, "role": v });
+        }
+      }
+      data = result;
+    }
+    return data.map(item => Message.load(item as Record<string, unknown>, context));
+  }
+
+  static saveMessages(items: Message[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    // This type doesn't have a 'name' property, so always use array format
+    return items.map(item => item.save(context));
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.messages !== undefined && obj.messages !== null) {
+      result["messages"] = ToolContext.saveMessages(obj.messages, context);
+    }
+    if (obj.metadata !== undefined && obj.metadata !== null) {
+      result["metadata"] = obj.metadata;
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ToolContext {
+    const data = JSON.parse(json);
+    return ToolContext.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ToolContext {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ToolContext.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/tool-dispatch-result.ts b/runtime/typescript/packages/core/src/model/tool-dispatch-result.ts
new file mode 100644
index 00000000..b00404a9
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/tool-dispatch-result.ts
@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+import { ToolResult } from "./tool-result";
+
+export class ToolDispatchResult {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  toolCallId: string = "";
+  name: string = "";
+  result!: ToolResult;
+
+  constructor(init?: Partial<ToolDispatchResult>) {
+    this.toolCallId = init?.toolCallId ?? "";
+    this.name = init?.name ?? "";
+    if (init?.result !== undefined) {
+      this.result = init.result;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ToolDispatchResult {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ToolDispatchResult();
+
+    if (data["toolCallId"] !== undefined && data["toolCallId"] !== null) {
+      instance.toolCallId = String(data["toolCallId"]);
+    }
+    if (data["name"] !== undefined && data["name"] !== null) {
+      instance.name = String(data["name"]);
+    }
+    if (data["result"] !== undefined && data["result"] !== null) {
+      instance.result = ToolResult.load(data["result"] as Record<string, unknown>, context);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ToolDispatchResult;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.toolCallId !== undefined && obj.toolCallId !== null) {
+      result["toolCallId"] = obj.toolCallId;
+    }
+    if (obj.name !== undefined && obj.name !== null) {
+      result["name"] = obj.name;
+    }
+    if (obj.result !== undefined && obj.result !== null) {
+      result["result"] = obj.result.save(context);
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ToolDispatchResult {
+    const data = JSON.parse(json);
+    return ToolDispatchResult.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ToolDispatchResult {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ToolDispatchResult.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/tool-result-payload.ts b/runtime/typescript/packages/core/src/model/tool-result-payload.ts
new file mode 100644
index 00000000..616b5d34
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/tool-result-payload.ts
@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+import { ToolResult } from "./tool-result";
+
+export class ToolResultPayload {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  name: string = "";
+  result!: ToolResult;
+
+  constructor(init?: Partial<ToolResultPayload>) {
+    this.name = init?.name ?? "";
+    if (init?.result !== undefined) {
+      this.result = init.result;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ToolResultPayload {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ToolResultPayload();
+
+    if (data["name"] !== undefined && data["name"] !== null) {
+      instance.name = String(data["name"]);
+    }
+    if (data["result"] !== undefined && data["result"] !== null) {
+      instance.result = ToolResult.load(data["result"] as Record<string, unknown>, context);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ToolResultPayload;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.name !== undefined && obj.name !== null) {
+      result["name"] = obj.name;
+    }
+    if (obj.result !== undefined && obj.result !== null) {
+      result["result"] = obj.result.save(context);
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ToolResultPayload {
+    const data = JSON.parse(json);
+    return ToolResultPayload.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ToolResultPayload {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ToolResultPayload.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/src/model/tool-result.ts b/runtime/typescript/packages/core/src/model/tool-result.ts
new file mode 100644
index 00000000..a788af01
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/tool-result.ts
@@ -0,0 +1,123 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+import { ContentPart, TextPart } from "./content-part";
+
+export class ToolResult {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  parts: ContentPart[] = [];
+
+  constructor(init?: Partial<ToolResult>) {
+    this.parts = init?.parts ?? [];
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): ToolResult {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new ToolResult();
+
+    if (data["parts"] !== undefined && data["parts"] !== null) {
+      instance.parts = ToolResult.loadParts(data["parts"] as unknown[], context);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as ToolResult;
+    }
+    return instance;
+  }
+
+  static loadParts(data: Record<string, unknown>[] | unknown[], context?: LoadContext): ContentPart[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
+        } else {
+          result.push({ name: k, "kind": v });
+        }
+      }
+      data = result;
+    }
+    return data.map(item => ContentPart.load(item as Record<string, unknown>, context));
+  }
+
+  static saveParts(items: ContentPart[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    // This type doesn't have a 'name' property, so always use array format
+    return items.map(item => item.save(context));
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.parts !== undefined && obj.parts !== null) {
+      result["parts"] = ToolResult.saveParts(obj.parts, context);
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): ToolResult {
+    const data = JSON.parse(json);
+    return ToolResult.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): ToolResult {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return ToolResult.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+
+  static text(value: string): ToolResult {
+    return new ToolResult({ parts: [new TextPart({ value: value })] });
+  }
+
+}
+
+/**
+ * Helper contract for `ToolResult`.
+ *
+ * Runtime implementations must provide these methods on every ToolResult
+ * instance (either on the generated class or on a wrapper type). The
+ * TypeScript compiler enforces conformance wherever a value is typed as
+ * `ToolResultHelpers`.
+ */
+export interface ToolResultHelpers {
+  /** Concatenate all TextPart values joined by newline */
+  readonly text: string;
+}
+
diff --git a/runtime/typescript/packages/core/src/model/tool.ts b/runtime/typescript/packages/core/src/model/tool.ts
index 6c42b658..481b8458 100644
--- a/runtime/typescript/packages/core/src/model/tool.ts
+++ b/runtime/typescript/packages/core/src/model/tool.ts
@@ -7,48 +7,20 @@ import { Connection } from "./connection";
 import { McpApprovalMode } from "./mcp-approval-mode";
 import { Property } from "./property";
 
-/**
- * Represents a tool that can be used in prompts.
- *
- */
 export abstract class Tool {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * Name of the tool. If a function tool, this is the function name, otherwise it is the type
-   */
   name: string = "";
-
-  /**
-   * The kind identifier for the tool
-   */
   kind: string = "";
-
-  /**
-   * A short description of the tool for metadata purposes
-   */
   description?: string | undefined;
-
-  /**
-   * Tool argument bindings to input properties
-   */
   bindings?: Binding[] = [];
 
-  /**
-   * Initializes a new instance of Tool.
-   */
   constructor(init?: Partial<Tool>) {
     this.name = init?.name ?? "";
-
     this.kind = init?.kind ?? "";
-
     if (init?.description !== undefined) {
       this.description = init.description;
     }
-
     if (init?.bindings !== undefined) {
       this.bindings = init.bindings;
     }
@@ -56,15 +28,9 @@ export abstract class Tool {
 
   //#region Load Methods
 
-  /**
-   * Load a Tool instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Tool instance.
-   */
   static load(data: Record<string, unknown>, context?: LoadContext): Tool {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
     // Load polymorphic Tool instance
@@ -73,17 +39,14 @@ export abstract class Tool {
     if (data["name"] !== undefined && data["name"] !== null) {
       instance.name = String(data["name"]);
     }
-
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["description"] !== undefined && data["description"] !== null) {
       instance.description = String(data["description"]);
     }
-
     if (data["bindings"] !== undefined && data["bindings"] !== null) {
-      instance.bindings = Tool.loadBindings(data["bindings"], context);
+      instance.bindings = Tool.loadBindings(data["bindings"] as unknown[], context);
     }
 
     if (context) {
@@ -92,59 +55,7 @@ export abstract class Tool {
     return instance;
   }
 
-  /**
-   * Load a collection of Binding from a dictionary or array.
-   * @param data - The data to load from.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded array of Binding.
-   */
-  static loadBindings(data: unknown, context?: LoadContext): Binding[] {
-    const result: Binding[] = [];
-
-    if (data && typeof data === "object" && !Array.isArray(data)) {
-      // Convert named dictionary to array
-      for (const [key, value] of Object.entries(
-        data as Record<string, unknown>,
-      )) {
-        if (Array.isArray(value)) {
-          throw new Error(
-            `Invalid 'bindings' format: key '${key}' has an array value. ` +
-              `'bindings' must be a flat list of objects or a name-keyed dict — ` +
-              `not a nested { ${key}: [...] } structure.`,
-          );
-        }
-        if (value && typeof value === "object") {
-          // Value is an object, add name to it
-          (value as Record<string, unknown>)["name"] = key;
-          result.push(Binding.load(value as Record<string, unknown>, context));
-        } else {
-          // Value is a scalar — let Binding.load() infer kind from value
-          const prop = Binding.load(value as Record<string, unknown>, context);
-          prop.name = key;
-          result.push(prop);
-        }
-      }
-    } else if (Array.isArray(data)) {
-      for (const item of data) {
-        if (item && typeof item === "object") {
-          result.push(Binding.load(item as Record<string, unknown>, context));
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Load polymorphic Tool based on discriminator.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Tool instance.
-   */
-  private static loadKind(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): Tool {
+  private static loadKind(data: Record<string, unknown>, context?: LoadContext): Tool {
     const discriminatorValue = data["kind"];
     if (discriminatorValue !== undefined && discriminatorValue !== null) {
       const discriminator = String(discriminatorValue).toLowerCase();
@@ -161,36 +72,80 @@ export abstract class Tool {
           return CustomTool.load(data, context);
       }
     }
-
     throw new Error("Missing Tool discriminator property: 'kind'");
   }
 
+  static loadBindings(data: Record<string, unknown>[] | unknown[], context?: LoadContext): Binding[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
+        } else {
+          result.push({ name: k, "input": v });
+        }
+      }
+      data = result;
+    }
+    return data.map(item => Binding.load(item as Record<string, unknown>, context));
+  }
+
+  static saveBindings(items: Binding[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    if (context.collectionFormat === "array") {
+      return items.map(item => item.save(context));
+    }
+
+    // Object format: use name as key
+    const result: Record<string, unknown> = {};
+    for (const item of items) {
+      const itemData = item.save(context) as Record<string, unknown>;
+      const name = itemData["name"] as string | undefined;
+      delete itemData["name"];
+      if (name) {
+        // Check if we can use shorthand (only primary property set)
+        const shorthand = (item.constructor as typeof Binding).shorthandProperty;
+        if (context.useShorthand && shorthand && Object.keys(itemData).length === 1 && shorthand in itemData) {
+          result[name] = itemData[shorthand];
+          continue;
+        }
+        result[name] = itemData;
+      } else {
+        // No name, fall back to array format for this item
+        if (!result["_unnamed"]) {
+          result["_unnamed"] = [];
+        }
+        (result["_unnamed"] as unknown[]).push(itemData);
+      }
+    }
+    return result;
+  }
+
   //#endregion
 
   //#region Save Methods
 
-  /**
-   * Save the Tool instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as Tool) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     const result: Record<string, unknown> = {};
 
     if (obj.name !== undefined && obj.name !== null) {
       result["name"] = obj.name;
     }
-
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.description !== undefined && obj.description !== null) {
       result["description"] = obj.description;
     }
-
     if (obj.bindings !== undefined && obj.bindings !== null) {
       result["bindings"] = Tool.saveBindings(obj.bindings, context);
     }
@@ -198,137 +153,44 @@ export abstract class Tool {
     if (context) {
       return context.processDict(result);
     }
-
     return result;
   }
 
-  /**
-   * Save a collection of Binding to object or array format.
-   * @param items - The items to save.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The saved collection in object or array format.
-   */
-  static saveBindings(
-    items: Binding[],
-    context?: SaveContext,
-  ): Record<string, unknown> | Record<string, unknown>[] {
-    context = context ?? new SaveContext();
-
-    if (context.collectionFormat === "array") {
-      return items.map((item) => item.save(context));
-    }
-
-    // Object format: use name as key
-    const result: Record<string, unknown> = {};
-    for (const item of items) {
-      const itemData = item.save(context);
-      const name = itemData["name"] as string | undefined;
-      if (name) {
-        delete itemData["name"];
-
-        // Check if we can use shorthand
-        if (context.useShorthand && Binding.shorthandProperty) {
-          const shorthandProp = Binding.shorthandProperty;
-          const keys = Object.keys(itemData);
-          if (keys.length === 1 && keys[0] === shorthandProp) {
-            result[name] = itemData[shorthandProp];
-            continue;
-          }
-        }
-        result[name] = itemData;
-      } else {
-        throw new Error(
-          "Cannot save item in object format: missing 'name' property",
-        );
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Convert the Tool instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the Tool instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a Tool instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Tool instance.
-   */
   static fromJson(json: string, context?: LoadContext): Tool {
     const data = JSON.parse(json);
-
     return Tool.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a Tool instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded Tool instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): Tool {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return Tool.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * Represents a local function tool.
- *
- */
 export class FunctionTool extends Tool {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The kind identifier for function tools
-   */
   kind: string = "function";
-
-  /**
-   * Parameters accepted by the function tool
-   */
   parameters: Property[] = [];
-
-  /**
-   * Indicates whether the function tool enforces strict validation on its parameters
-   */
   strict?: boolean | undefined;
 
-  /**
-   * Initializes a new instance of FunctionTool.
-   */
   constructor(init?: Partial<FunctionTool>) {
     super(init);
-
     this.kind = init?.kind ?? "function";
-
     this.parameters = init?.parameters ?? [];
-
     if (init?.strict !== undefined) {
       this.strict = init.strict;
     }
@@ -336,34 +198,19 @@ export class FunctionTool extends Tool {
 
   //#region Load Methods
 
-  /**
-   * Load a FunctionTool instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded FunctionTool instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): FunctionTool {
+  static load(data: Record<string, unknown>, context?: LoadContext): FunctionTool {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new FunctionTool();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["parameters"] !== undefined && data["parameters"] !== null) {
-      instance.parameters = FunctionTool.loadParameters(
-        data["parameters"],
-        context,
-      );
+      instance.parameters = FunctionTool.loadParameters(data["parameters"] as unknown[], context);
     }
-
     if (data["strict"] !== undefined && data["strict"] !== null) {
       instance.strict = Boolean(data["strict"]);
     }
@@ -374,60 +221,40 @@ export class FunctionTool extends Tool {
     return instance;
   }
 
-  /**
-   * Load a collection of Property from a dictionary or array.
-   * @param data - The data to load from.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded array of Property.
-   */
-  static loadParameters(data: unknown, context?: LoadContext): Property[] {
-    const result: Property[] = [];
-
-    if (data && typeof data === "object" && !Array.isArray(data)) {
-      // Convert named dictionary to array
-      for (const [key, value] of Object.entries(
-        data as Record<string, unknown>,
-      )) {
-        if (Array.isArray(value)) {
-          throw new Error(
-            `Invalid 'parameters' format: key '${key}' has an array value. ` +
-              `'parameters' must be a flat list of objects or a name-keyed dict — ` +
-              `not a nested { ${key}: [...] } structure.`,
-          );
-        }
-        if (value && typeof value === "object") {
-          // Value is an object, add name to it
-          (value as Record<string, unknown>)["name"] = key;
-          result.push(Property.load(value as Record<string, unknown>, context));
+  static loadParameters(data: Record<string, unknown>[] | unknown[], context?: LoadContext): Property[] {
+    if (!Array.isArray(data)) {
+      // Convert dict/object format to array format
+      const result: Record<string, unknown>[] = [];
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+          result.push({ name: k, ...(v as Record<string, unknown>) });
         } else {
-          // Value is a scalar — let Property.load() infer kind from value
-          const prop = Property.load(value as Record<string, unknown>, context);
-          prop.name = key;
-          result.push(prop);
-        }
-      }
-    } else if (Array.isArray(data)) {
-      for (const item of data) {
-        if (item && typeof item === "object") {
-          result.push(Property.load(item as Record<string, unknown>, context));
+          result.push({ name: k, "kind": v });
         }
       }
+      data = result;
     }
+    return data.map(item => Property.load(item as Record<string, unknown>, context));
+  }
 
-    return result;
+  static saveParameters(items: Property[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {
+    if (!context) {
+      context = new SaveContext();
+    }
+
+    // This type doesn't have a 'name' property, so always use array format
+    return items.map(item => item.save(context));
   }
 
   //#endregion
 
   //#region Save Methods
 
-  /**
-   * Save the FunctionTool instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as FunctionTool) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -435,158 +262,70 @@ export class FunctionTool extends Tool {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.parameters !== undefined && obj.parameters !== null) {
-      result["parameters"] = FunctionTool.saveParameters(
-        obj.parameters,
-        context,
-      );
+      result["parameters"] = FunctionTool.saveParameters(obj.parameters, context);
     }
-
     if (obj.strict !== undefined && obj.strict !== null) {
       result["strict"] = obj.strict;
     }
-
     return result;
   }
 
-  /**
-   * Save a collection of Property to object or array format.
-   * @param items - The items to save.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The saved collection in object or array format.
-   */
-  static saveParameters(
-    items: Property[],
-    context?: SaveContext,
-  ): Record<string, unknown> | Record<string, unknown>[] {
-    context = context ?? new SaveContext();
-
-    // This type doesn't have a 'name' property, so always use array format
-    return items.map((item) => item.save(context));
-  }
-
-  /**
-   * Convert the FunctionTool instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the FunctionTool instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a FunctionTool instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded FunctionTool instance.
-   */
   static fromJson(json: string, context?: LoadContext): FunctionTool {
     const data = JSON.parse(json);
-
     return FunctionTool.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a FunctionTool instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded FunctionTool instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): FunctionTool {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return FunctionTool.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * Represents a generic server tool that runs on a server
- * This tool kind is designed for operations that require server-side execution
- * It may include features such as authentication, data storage, and long-running processes
- * This tool kind is ideal for tasks that involve complex computations or access to secure resources
- * Server tools can be used to offload heavy processing from client applications
- *
- */
 export class CustomTool extends Tool {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The kind identifier for server tools. This is a wildcard and can represent any server tool type not explicitly defined.
-   */
   kind: string = "*";
-
-  /**
-   * Connection configuration for the server tool
-   */
-  connection: Connection;
-
-  /**
-   * Configuration options for the server tool
-   */
+  connection!: Connection;
   options: Record<string, unknown> = {};
 
-  /**
-   * Initializes a new instance of CustomTool.
-   */
   constructor(init?: Partial<CustomTool>) {
     super(init);
-
     this.kind = init?.kind ?? "*";
-
-    this.connection = init?.connection ?? undefined!;
-
+    if (init?.connection !== undefined) {
+      this.connection = init.connection;
+    }
     this.options = init?.options ?? {};
   }
 
   //#region Load Methods
 
-  /**
-   * Load a CustomTool instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded CustomTool instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): CustomTool {
+  static load(data: Record<string, unknown>, context?: LoadContext): CustomTool {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new CustomTool();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["connection"] !== undefined && data["connection"] !== null) {
-      instance.connection = Connection.load(
-        data["connection"] as Record<string, unknown>,
-        context,
-      );
+      instance.connection = Connection.load(data["connection"] as Record<string, unknown>, context);
     }
-
     if (data["options"] !== undefined && data["options"] !== null) {
       instance.options = data["options"] as Record<string, unknown>;
     }
@@ -601,13 +340,11 @@ export class CustomTool extends Tool {
 
   //#region Save Methods
 
-  /**
-   * Save the CustomTool instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as CustomTool) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -615,125 +352,62 @@ export class CustomTool extends Tool {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.connection !== undefined && obj.connection !== null) {
-      result["connection"] = obj.connection?.save(context);
+      result["connection"] = obj.connection.save(context);
     }
-
     if (obj.options !== undefined && obj.options !== null) {
       result["options"] = obj.options;
     }
-
     return result;
   }
 
-  /**
-   * Convert the CustomTool instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the CustomTool instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a CustomTool instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded CustomTool instance.
-   */
   static fromJson(json: string, context?: LoadContext): CustomTool {
     const data = JSON.parse(json);
-
     return CustomTool.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a CustomTool instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded CustomTool instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): CustomTool {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return CustomTool.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * The MCP Server tool.
- *
- */
 export class McpTool extends Tool {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The kind identifier for MCP tools
-   */
   kind: string = "mcp";
-
-  /**
-   * The connection configuration for the MCP tool
-   */
-  connection: Connection;
-
-  /**
-   * The server name of the MCP tool
-   */
+  connection!: Connection;
   serverName: string = "";
-
-  /**
-   * The description of the MCP tool
-   */
   serverDescription?: string | undefined;
-
-  /**
-   * The approval mode for the MCP tool
-   */
-  approvalMode: McpApprovalMode;
-
-  /**
-   * List of allowed operations or resources for the MCP tool
-   */
+  approvalMode!: McpApprovalMode;
   allowedTools?: string[] = [];
 
-  /**
-   * Initializes a new instance of McpTool.
-   */
   constructor(init?: Partial<McpTool>) {
     super(init);
-
     this.kind = init?.kind ?? "mcp";
-
-    this.connection = init?.connection ?? undefined!;
-
+    if (init?.connection !== undefined) {
+      this.connection = init.connection;
+    }
     this.serverName = init?.serverName ?? "";
-
     if (init?.serverDescription !== undefined) {
       this.serverDescription = init.serverDescription;
     }
-
-    this.approvalMode = init?.approvalMode ?? undefined!;
-
+    if (init?.approvalMode !== undefined) {
+      this.approvalMode = init.approvalMode;
+    }
     if (init?.allowedTools !== undefined) {
       this.allowedTools = init.allowedTools;
     }
@@ -741,53 +415,30 @@ export class McpTool extends Tool {
 
   //#region Load Methods
 
-  /**
-   * Load a McpTool instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded McpTool instance.
-   */
   static load(data: Record<string, unknown>, context?: LoadContext): McpTool {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new McpTool();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["connection"] !== undefined && data["connection"] !== null) {
-      instance.connection = Connection.load(
-        data["connection"] as Record<string, unknown>,
-        context,
-      );
+      instance.connection = Connection.load(data["connection"] as Record<string, unknown>, context);
     }
-
     if (data["serverName"] !== undefined && data["serverName"] !== null) {
       instance.serverName = String(data["serverName"]);
     }
-
-    if (
-      data["serverDescription"] !== undefined &&
-      data["serverDescription"] !== null
-    ) {
+    if (data["serverDescription"] !== undefined && data["serverDescription"] !== null) {
       instance.serverDescription = String(data["serverDescription"]);
     }
-
     if (data["approvalMode"] !== undefined && data["approvalMode"] !== null) {
-      instance.approvalMode = McpApprovalMode.load(
-        data["approvalMode"] as Record<string, unknown>,
-        context,
-      );
+      instance.approvalMode = McpApprovalMode.load(data["approvalMode"] as Record<string, unknown>, context);
     }
-
     if (data["allowedTools"] !== undefined && data["allowedTools"] !== null) {
-      instance.allowedTools = Array.isArray(data["allowedTools"])
-        ? (data["allowedTools"] as unknown[]).map((v) => String(v))
-        : [];
+      instance.allowedTools = (data["allowedTools"] as unknown[]).map(v => String(v));
     }
 
     if (context) {
@@ -800,13 +451,11 @@ export class McpTool extends Tool {
 
   //#region Save Methods
 
-  /**
-   * Save the McpTool instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as McpTool) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -814,147 +463,79 @@ export class McpTool extends Tool {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.connection !== undefined && obj.connection !== null) {
-      result["connection"] = obj.connection?.save(context);
+      result["connection"] = obj.connection.save(context);
     }
-
     if (obj.serverName !== undefined && obj.serverName !== null) {
       result["serverName"] = obj.serverName;
     }
-
     if (obj.serverDescription !== undefined && obj.serverDescription !== null) {
       result["serverDescription"] = obj.serverDescription;
     }
-
     if (obj.approvalMode !== undefined && obj.approvalMode !== null) {
-      result["approvalMode"] = obj.approvalMode?.save(context);
+      result["approvalMode"] = obj.approvalMode.save(context);
     }
-
     if (obj.allowedTools !== undefined && obj.allowedTools !== null) {
       result["allowedTools"] = obj.allowedTools;
     }
-
     return result;
   }
 
-  /**
-   * Convert the McpTool instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the McpTool instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a McpTool instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded McpTool instance.
-   */
   static fromJson(json: string, context?: LoadContext): McpTool {
     const data = JSON.parse(json);
-
     return McpTool.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a McpTool instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded McpTool instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): McpTool {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return McpTool.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- *
- *
- */
 export class OpenApiTool extends Tool {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The kind identifier for OpenAPI tools
-   */
   kind: string = "openapi";
-
-  /**
-   * The connection configuration for the OpenAPI tool
-   */
-  connection: Connection;
-
-  /**
-   * The full OpenAPI specification
-   */
+  connection!: Connection;
   specification: string = "";
 
-  /**
-   * Initializes a new instance of OpenApiTool.
-   */
   constructor(init?: Partial<OpenApiTool>) {
     super(init);
-
     this.kind = init?.kind ?? "openapi";
-
-    this.connection = init?.connection ?? undefined!;
-
+    if (init?.connection !== undefined) {
+      this.connection = init.connection;
+    }
     this.specification = init?.specification ?? "";
   }
 
   //#region Load Methods
 
-  /**
-   * Load a OpenApiTool instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded OpenApiTool instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): OpenApiTool {
+  static load(data: Record<string, unknown>, context?: LoadContext): OpenApiTool {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new OpenApiTool();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["connection"] !== undefined && data["connection"] !== null) {
-      instance.connection = Connection.load(
-        data["connection"] as Record<string, unknown>,
-        context,
-      );
+      instance.connection = Connection.load(data["connection"] as Record<string, unknown>, context);
     }
-
     if (data["specification"] !== undefined && data["specification"] !== null) {
       instance.specification = String(data["specification"]);
     }
@@ -969,13 +550,11 @@ export class OpenApiTool extends Tool {
 
   //#region Save Methods
 
-  /**
-   * Save the OpenApiTool instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as OpenApiTool) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -983,135 +562,68 @@ export class OpenApiTool extends Tool {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.connection !== undefined && obj.connection !== null) {
-      result["connection"] = obj.connection?.save(context);
+      result["connection"] = obj.connection.save(context);
     }
-
     if (obj.specification !== undefined && obj.specification !== null) {
       result["specification"] = obj.specification;
     }
-
     return result;
   }
 
-  /**
-   * Convert the OpenApiTool instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the OpenApiTool instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a OpenApiTool instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded OpenApiTool instance.
-   */
   static fromJson(json: string, context?: LoadContext): OpenApiTool {
     const data = JSON.parse(json);
-
     return OpenApiTool.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a OpenApiTool instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded OpenApiTool instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): OpenApiTool {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return OpenApiTool.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
 
-/**
- * A tool that references another .prompty file to be invoked as a tool.
- *
- * In `single` mode, the child prompty is executed with a single LLM call.
- * In `agentic` mode, the child prompty runs a full agent loop with its own tools.
- *
- */
 export class PromptyTool extends Tool {
-  /**
-   * The shorthand property name for this type, if any.
-   */
   static readonly shorthandProperty: string | undefined = undefined;
 
-  /**
-   * The kind identifier for prompty tools
-   */
   kind: string = "prompty";
-
-  /**
-   * Path to the child .prompty file, relative to the parent
-   */
   path: string = "";
-
-  /**
-   * Execution mode: 'single' for one LLM call, 'agentic' for full agent loop
-   */
   mode: string = "single";
 
-  /**
-   * Initializes a new instance of PromptyTool.
-   */
   constructor(init?: Partial<PromptyTool>) {
     super(init);
-
     this.kind = init?.kind ?? "prompty";
-
     this.path = init?.path ?? "";
-
     this.mode = init?.mode ?? "single";
   }
 
   //#region Load Methods
 
-  /**
-   * Load a PromptyTool instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded PromptyTool instance.
-   */
-  static load(
-    data: Record<string, unknown>,
-    context?: LoadContext,
-  ): PromptyTool {
+  static load(data: Record<string, unknown>, context?: LoadContext): PromptyTool {
     if (context) {
-      data = context.processInput(data);
+      data = context.processInput(data) as Record<string, unknown>;
     }
 
-    // Create new instance
     const instance = new PromptyTool();
 
     if (data["kind"] !== undefined && data["kind"] !== null) {
       instance.kind = String(data["kind"]);
     }
-
     if (data["path"] !== undefined && data["path"] !== null) {
       instance.path = String(data["path"]);
     }
-
     if (data["mode"] !== undefined && data["mode"] !== null) {
       instance.mode = String(data["mode"]);
     }
@@ -1126,13 +638,11 @@ export class PromptyTool extends Tool {
 
   //#region Save Methods
 
-  /**
-   * Save the PromptyTool instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
   save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? (context.processObject(this) as PromptyTool) : this;
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
 
     // Start with parent class properties
     const result = super.save(context);
@@ -1140,63 +650,36 @@ export class PromptyTool extends Tool {
     if (obj.kind !== undefined && obj.kind !== null) {
       result["kind"] = obj.kind;
     }
-
     if (obj.path !== undefined && obj.path !== null) {
       result["path"] = obj.path;
     }
-
     if (obj.mode !== undefined && obj.mode !== null) {
       result["mode"] = obj.mode;
     }
-
     return result;
   }
 
-  /**
-   * Convert the PromptyTool instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
   toYaml(context?: SaveContext): string {
     context = context ?? new SaveContext();
     return context.toYaml(this.save(context));
   }
 
-  /**
-   * Convert the PromptyTool instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
   toJson(context?: SaveContext, indent: number = 2): string {
     context = context ?? new SaveContext();
     return context.toJson(this.save(context), indent);
   }
 
-  /**
-   * Load a PromptyTool instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded PromptyTool instance.
-   */
   static fromJson(json: string, context?: LoadContext): PromptyTool {
     const data = JSON.parse(json);
-
     return PromptyTool.load(data as Record<string, unknown>, context);
   }
 
-  /**
-   * Load a PromptyTool instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded PromptyTool instance.
-   */
   static fromYaml(yaml: string, context?: LoadContext): PromptyTool {
     const { parse } = require("yaml");
     const data = parse(yaml);
-
     return PromptyTool.load(data as Record<string, unknown>, context);
   }
 
   //#endregion
 }
+
diff --git a/runtime/typescript/packages/core/src/model/turn-options.ts b/runtime/typescript/packages/core/src/model/turn-options.ts
new file mode 100644
index 00000000..133b3b13
--- /dev/null
+++ b/runtime/typescript/packages/core/src/model/turn-options.ts
@@ -0,0 +1,142 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { LoadContext, SaveContext } from "./context";
+import { CompactionConfig } from "./compaction-config";
+
+export class TurnOptions {
+  static readonly shorthandProperty: string | undefined = undefined;
+
+  maxIterations?: number | undefined;
+  maxLlmRetries?: number | undefined;
+  contextBudget?: number | undefined;
+  parallelToolCalls?: boolean | undefined;
+  raw?: boolean | undefined;
+  turn?: number | undefined;
+  compaction?: CompactionConfig | undefined;
+
+  constructor(init?: Partial<TurnOptions>) {
+    if (init?.maxIterations !== undefined) {
+      this.maxIterations = init.maxIterations;
+    }
+    if (init?.maxLlmRetries !== undefined) {
+      this.maxLlmRetries = init.maxLlmRetries;
+    }
+    if (init?.contextBudget !== undefined) {
+      this.contextBudget = init.contextBudget;
+    }
+    if (init?.parallelToolCalls !== undefined) {
+      this.parallelToolCalls = init.parallelToolCalls;
+    }
+    if (init?.raw !== undefined) {
+      this.raw = init.raw;
+    }
+    if (init?.turn !== undefined) {
+      this.turn = init.turn;
+    }
+    if (init?.compaction !== undefined) {
+      this.compaction = init.compaction;
+    }
+  }
+
+  //#region Load Methods
+
+  static load(data: Record<string, unknown>, context?: LoadContext): TurnOptions {
+    if (context) {
+      data = context.processInput(data) as Record<string, unknown>;
+    }
+
+    const instance = new TurnOptions();
+
+    if (data["maxIterations"] !== undefined && data["maxIterations"] !== null) {
+      instance.maxIterations = Number(data["maxIterations"]);
+    }
+    if (data["maxLlmRetries"] !== undefined && data["maxLlmRetries"] !== null) {
+      instance.maxLlmRetries = Number(data["maxLlmRetries"]);
+    }
+    if (data["contextBudget"] !== undefined && data["contextBudget"] !== null) {
+      instance.contextBudget = Number(data["contextBudget"]);
+    }
+    if (data["parallelToolCalls"] !== undefined && data["parallelToolCalls"] !== null) {
+      instance.parallelToolCalls = Boolean(data["parallelToolCalls"]);
+    }
+    if (data["raw"] !== undefined && data["raw"] !== null) {
+      instance.raw = Boolean(data["raw"]);
+    }
+    if (data["turn"] !== undefined && data["turn"] !== null) {
+      instance.turn = Number(data["turn"]);
+    }
+    if (data["compaction"] !== undefined && data["compaction"] !== null) {
+      instance.compaction = CompactionConfig.load(data["compaction"] as Record<string, unknown>, context);
+    }
+
+    if (context) {
+      return context.processOutput(instance) as TurnOptions;
+    }
+    return instance;
+  }
+
+  //#endregion
+
+  //#region Save Methods
+
+  save(context?: SaveContext): Record<string, unknown> {
+    let obj: this = this;
+    if (context) {
+      obj = context.processObject(obj) as this;
+    }
+
+    const result: Record<string, unknown> = {};
+
+    if (obj.maxIterations !== undefined && obj.maxIterations !== null) {
+      result["maxIterations"] = obj.maxIterations;
+    }
+    if (obj.maxLlmRetries !== undefined && obj.maxLlmRetries !== null) {
+      result["maxLlmRetries"] = obj.maxLlmRetries;
+    }
+    if (obj.contextBudget !== undefined && obj.contextBudget !== null) {
+      result["contextBudget"] = obj.contextBudget;
+    }
+    if (obj.parallelToolCalls !== undefined && obj.parallelToolCalls !== null) {
+      result["parallelToolCalls"] = obj.parallelToolCalls;
+    }
+    if (obj.raw !== undefined && obj.raw !== null) {
+      result["raw"] = obj.raw;
+    }
+    if (obj.turn !== undefined && obj.turn !== null) {
+      result["turn"] = obj.turn;
+    }
+    if (obj.compaction !== undefined && obj.compaction !== null) {
+      result["compaction"] = obj.compaction.save(context);
+    }
+
+    if (context) {
+      return context.processDict(result);
+    }
+    return result;
+  }
+
+  toYaml(context?: SaveContext): string {
+    context = context ?? new SaveContext();
+    return context.toYaml(this.save(context));
+  }
+
+  toJson(context?: SaveContext, indent: number = 2): string {
+    context = context ?? new SaveContext();
+    return context.toJson(this.save(context), indent);
+  }
+
+  static fromJson(json: string, context?: LoadContext): TurnOptions {
+    const data = JSON.parse(json);
+    return TurnOptions.load(data as Record<string, unknown>, context);
+  }
+
+  static fromYaml(yaml: string, context?: LoadContext): TurnOptions {
+    const { parse } = require("yaml");
+    const data = parse(yaml);
+    return TurnOptions.load(data as Record<string, unknown>, context);
+  }
+
+  //#endregion
+}
+
diff --git a/runtime/typescript/packages/core/tests/model/anonymous-connection.test.ts b/runtime/typescript/packages/core/tests/model/anonymous-connection.test.ts
index 8116f252..f5edda33 100644
--- a/runtime/typescript/packages/core/tests/model/anonymous-connection.test.ts
+++ b/runtime/typescript/packages/core/tests/model/anonymous-connection.test.ts
@@ -21,12 +21,8 @@ describe("AnonymousConnection", () => {
       const json = `{\n  "kind": "anonymous",\n  "endpoint": "https://{your-custom-endpoint}.openai.azure.com/"\n}`;
       const instance = AnonymousConnection.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("anonymous");
-
-      expect(instance.endpoint).toEqual(
-        "https://{your-custom-endpoint}.openai.azure.com/",
-      );
+      expect(instance.endpoint).toEqual("https://{your-custom-endpoint}.openai.azure.com/");
     });
 
     it("should round-trip JSON - example 1", () => {
@@ -34,9 +30,7 @@ describe("AnonymousConnection", () => {
       const instance = AnonymousConnection.fromJson(json);
       const output = instance.toJson();
       const reloaded = AnonymousConnection.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
     });
   });
@@ -46,12 +40,8 @@ describe("AnonymousConnection", () => {
       const yaml = `kind: anonymous\nendpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n`;
       const instance = AnonymousConnection.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("anonymous");
-
-      expect(instance.endpoint).toEqual(
-        "https://{your-custom-endpoint}.openai.azure.com/",
-      );
+      expect(instance.endpoint).toEqual("https://{your-custom-endpoint}.openai.azure.com/");
     });
 
     it("should round-trip YAML - example 1", () => {
@@ -59,9 +49,7 @@ describe("AnonymousConnection", () => {
       const instance = AnonymousConnection.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = AnonymousConnection.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/api-key-connection.test.ts b/runtime/typescript/packages/core/tests/model/api-key-connection.test.ts
index 0f0fcad3..797cbb19 100644
--- a/runtime/typescript/packages/core/tests/model/api-key-connection.test.ts
+++ b/runtime/typescript/packages/core/tests/model/api-key-connection.test.ts
@@ -21,13 +21,8 @@ describe("ApiKeyConnection", () => {
       const json = `{\n  "kind": "key",\n  "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n  "apiKey": "your-api-key"\n}`;
       const instance = ApiKeyConnection.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("key");
-
-      expect(instance.endpoint).toEqual(
-        "https://{your-custom-endpoint}.openai.azure.com/",
-      );
-
+      expect(instance.endpoint).toEqual("https://{your-custom-endpoint}.openai.azure.com/");
       expect(instance.apiKey).toEqual("your-api-key");
     });
 
@@ -36,11 +31,8 @@ describe("ApiKeyConnection", () => {
       const instance = ApiKeyConnection.fromJson(json);
       const output = instance.toJson();
       const reloaded = ApiKeyConnection.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
-
       expect(reloaded.apiKey).toEqual(instance.apiKey);
     });
   });
@@ -50,13 +42,8 @@ describe("ApiKeyConnection", () => {
       const yaml = `kind: key\nendpoint: "https://{your-custom-endpoint}.openai.azure.com/"\napiKey: your-api-key\n`;
       const instance = ApiKeyConnection.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("key");
-
-      expect(instance.endpoint).toEqual(
-        "https://{your-custom-endpoint}.openai.azure.com/",
-      );
-
+      expect(instance.endpoint).toEqual("https://{your-custom-endpoint}.openai.azure.com/");
       expect(instance.apiKey).toEqual("your-api-key");
     });
 
@@ -65,11 +52,8 @@ describe("ApiKeyConnection", () => {
       const instance = ApiKeyConnection.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = ApiKeyConnection.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
-
       expect(reloaded.apiKey).toEqual(instance.apiKey);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/audio-part.test.ts b/runtime/typescript/packages/core/tests/model/audio-part.test.ts
new file mode 100644
index 00000000..5af3c5b0
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/audio-part.test.ts
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { AudioPart } from "../../src/model/index";
+
+describe("AudioPart", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new AudioPart();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new AudioPart({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "source": "https://example.com/audio.wav",\n  "mediaType": "audio/wav"\n}`;
+      const instance = AudioPart.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.source).toEqual("https://example.com/audio.wav");
+      expect(instance.mediaType).toEqual("audio/wav");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "source": "https://example.com/audio.wav",\n  "mediaType": "audio/wav"\n}`;
+      const instance = AudioPart.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = AudioPart.fromJson(output);
+      expect(reloaded.source).toEqual(instance.source);
+      expect(reloaded.mediaType).toEqual(instance.mediaType);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `source: "https://example.com/audio.wav"\nmediaType: audio/wav\n`;
+      const instance = AudioPart.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.source).toEqual("https://example.com/audio.wav");
+      expect(instance.mediaType).toEqual("audio/wav");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `source: "https://example.com/audio.wav"\nmediaType: audio/wav\n`;
+      const instance = AudioPart.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = AudioPart.fromYaml(output);
+      expect(reloaded.source).toEqual(instance.source);
+      expect(reloaded.mediaType).toEqual(instance.mediaType);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = AudioPart.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new AudioPart();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/binding.test.ts b/runtime/typescript/packages/core/tests/model/binding.test.ts
index 9c995c57..26820f03 100644
--- a/runtime/typescript/packages/core/tests/model/binding.test.ts
+++ b/runtime/typescript/packages/core/tests/model/binding.test.ts
@@ -21,9 +21,7 @@ describe("Binding", () => {
       const json = `{\n  "name": "my-tool",\n  "input": "input-variable"\n}`;
       const instance = Binding.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("my-tool");
-
       expect(instance.input).toEqual("input-variable");
     });
 
@@ -32,9 +30,7 @@ describe("Binding", () => {
       const instance = Binding.fromJson(json);
       const output = instance.toJson();
       const reloaded = Binding.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.input).toEqual(instance.input);
     });
   });
@@ -44,9 +40,7 @@ describe("Binding", () => {
       const yaml = `name: my-tool\ninput: input-variable\n`;
       const instance = Binding.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("my-tool");
-
       expect(instance.input).toEqual("input-variable");
     });
 
@@ -55,9 +49,7 @@ describe("Binding", () => {
       const instance = Binding.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Binding.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.input).toEqual(instance.input);
     });
   });
@@ -68,7 +60,6 @@ describe("Binding", () => {
       const json = JSON.stringify(value);
       const instance = Binding.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.input).toEqual("example");
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/compaction-complete-payload.test.ts b/runtime/typescript/packages/core/tests/model/compaction-complete-payload.test.ts
new file mode 100644
index 00000000..4fba2d7e
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/compaction-complete-payload.test.ts
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { CompactionCompletePayload } from "../../src/model/index";
+
+describe("CompactionCompletePayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new CompactionCompletePayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new CompactionCompletePayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "removed": 5,\n  "remaining": 3\n}`;
+      const instance = CompactionCompletePayload.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.removed).toEqual(5);
+      expect(instance.remaining).toEqual(3);
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "removed": 5,\n  "remaining": 3\n}`;
+      const instance = CompactionCompletePayload.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = CompactionCompletePayload.fromJson(output);
+      expect(reloaded.removed).toEqual(instance.removed);
+      expect(reloaded.remaining).toEqual(instance.remaining);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `removed: 5\nremaining: 3\n`;
+      const instance = CompactionCompletePayload.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.removed).toEqual(5);
+      expect(instance.remaining).toEqual(3);
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `removed: 5\nremaining: 3\n`;
+      const instance = CompactionCompletePayload.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = CompactionCompletePayload.fromYaml(output);
+      expect(reloaded.removed).toEqual(instance.removed);
+      expect(reloaded.remaining).toEqual(instance.remaining);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = CompactionCompletePayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new CompactionCompletePayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/compaction-config.test.ts b/runtime/typescript/packages/core/tests/model/compaction-config.test.ts
new file mode 100644
index 00000000..b99dcb6d
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/compaction-config.test.ts
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { CompactionConfig } from "../../src/model/index";
+
+describe("CompactionConfig", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new CompactionConfig();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new CompactionConfig({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "strategy": "summarize",\n  "budget": 50000,\n  "options": {\n    "preserveSystemMessages": true\n  }\n}`;
+      const instance = CompactionConfig.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.strategy).toEqual("summarize");
+      expect(instance.budget).toEqual(50000);
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "strategy": "summarize",\n  "budget": 50000,\n  "options": {\n    "preserveSystemMessages": true\n  }\n}`;
+      const instance = CompactionConfig.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = CompactionConfig.fromJson(output);
+      expect(reloaded.strategy).toEqual(instance.strategy);
+      expect(reloaded.budget).toEqual(instance.budget);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `strategy: summarize\nbudget: 50000\noptions:\n  preserveSystemMessages: true\n`;
+      const instance = CompactionConfig.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.strategy).toEqual("summarize");
+      expect(instance.budget).toEqual(50000);
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `strategy: summarize\nbudget: 50000\noptions:\n  preserveSystemMessages: true\n`;
+      const instance = CompactionConfig.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = CompactionConfig.fromYaml(output);
+      expect(reloaded.strategy).toEqual(instance.strategy);
+      expect(reloaded.budget).toEqual(instance.budget);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = CompactionConfig.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new CompactionConfig();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/compaction-failed-payload.test.ts b/runtime/typescript/packages/core/tests/model/compaction-failed-payload.test.ts
new file mode 100644
index 00000000..8b142e45
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/compaction-failed-payload.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { CompactionFailedPayload } from "../../src/model/index";
+
+describe("CompactionFailedPayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new CompactionFailedPayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new CompactionFailedPayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "message": "Summarization prompt exceeded context window"\n}`;
+      const instance = CompactionFailedPayload.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.message).toEqual("Summarization prompt exceeded context window");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "message": "Summarization prompt exceeded context window"\n}`;
+      const instance = CompactionFailedPayload.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = CompactionFailedPayload.fromJson(output);
+      expect(reloaded.message).toEqual(instance.message);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `message: Summarization prompt exceeded context window\n`;
+      const instance = CompactionFailedPayload.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.message).toEqual("Summarization prompt exceeded context window");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `message: Summarization prompt exceeded context window\n`;
+      const instance = CompactionFailedPayload.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = CompactionFailedPayload.fromYaml(output);
+      expect(reloaded.message).toEqual(instance.message);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = CompactionFailedPayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new CompactionFailedPayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/connection.test.ts b/runtime/typescript/packages/core/tests/model/connection.test.ts
index 5b5c7d54..c6bc407f 100644
--- a/runtime/typescript/packages/core/tests/model/connection.test.ts
+++ b/runtime/typescript/packages/core/tests/model/connection.test.ts
@@ -21,14 +21,9 @@ describe("Connection", () => {
       const json = `{\n  "kind": "reference",\n  "authenticationMode": "system",\n  "usageDescription": "This will allow the agent to respond to an email on your behalf"\n}`;
       const instance = Connection.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("reference");
-
       expect(instance.authenticationMode).toEqual("system");
-
-      expect(instance.usageDescription).toEqual(
-        "This will allow the agent to respond to an email on your behalf",
-      );
+      expect(instance.usageDescription).toEqual("This will allow the agent to respond to an email on your behalf");
     });
 
     it("should round-trip JSON - example 1", () => {
@@ -36,11 +31,8 @@ describe("Connection", () => {
       const instance = Connection.fromJson(json);
       const output = instance.toJson();
       const reloaded = Connection.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.authenticationMode).toEqual(instance.authenticationMode);
-
       expect(reloaded.usageDescription).toEqual(instance.usageDescription);
     });
   });
@@ -50,14 +42,9 @@ describe("Connection", () => {
       const yaml = `kind: reference\nauthenticationMode: system\nusageDescription: This will allow the agent to respond to an email on your behalf\n`;
       const instance = Connection.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("reference");
-
       expect(instance.authenticationMode).toEqual("system");
-
-      expect(instance.usageDescription).toEqual(
-        "This will allow the agent to respond to an email on your behalf",
-      );
+      expect(instance.usageDescription).toEqual("This will allow the agent to respond to an email on your behalf");
     });
 
     it("should round-trip YAML - example 1", () => {
@@ -65,12 +52,10 @@ describe("Connection", () => {
       const instance = Connection.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Connection.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.authenticationMode).toEqual(instance.authenticationMode);
-
       expect(reloaded.usageDescription).toEqual(instance.usageDescription);
     });
   });
+
 });
diff --git a/runtime/typescript/packages/core/tests/model/content-part.test.ts b/runtime/typescript/packages/core/tests/model/content-part.test.ts
new file mode 100644
index 00000000..6ba5c544
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/content-part.test.ts
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ContentPart } from "../../src/model/index";
+
+describe("ContentPart", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ContentPart();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ContentPart({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+});
diff --git a/runtime/typescript/packages/core/tests/model/done-event-payload.test.ts b/runtime/typescript/packages/core/tests/model/done-event-payload.test.ts
new file mode 100644
index 00000000..a9aff819
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/done-event-payload.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { DoneEventPayload } from "../../src/model/index";
+
+describe("DoneEventPayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new DoneEventPayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new DoneEventPayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "response": "The weather in Paris is 72°F and sunny."\n}`;
+      const instance = DoneEventPayload.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.response).toEqual("The weather in Paris is 72°F and sunny.");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "response": "The weather in Paris is 72°F and sunny."\n}`;
+      const instance = DoneEventPayload.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = DoneEventPayload.fromJson(output);
+      expect(reloaded.response).toEqual(instance.response);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `response: The weather in Paris is 72°F and sunny.\n`;
+      const instance = DoneEventPayload.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.response).toEqual("The weather in Paris is 72°F and sunny.");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `response: The weather in Paris is 72°F and sunny.\n`;
+      const instance = DoneEventPayload.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = DoneEventPayload.fromYaml(output);
+      expect(reloaded.response).toEqual(instance.response);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = DoneEventPayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new DoneEventPayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/error-chunk.test.ts b/runtime/typescript/packages/core/tests/model/error-chunk.test.ts
new file mode 100644
index 00000000..6e4f678f
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/error-chunk.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ErrorChunk } from "../../src/model/index";
+
+describe("ErrorChunk", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ErrorChunk();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ErrorChunk({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "message": "Rate limit exceeded"\n}`;
+      const instance = ErrorChunk.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.message).toEqual("Rate limit exceeded");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "message": "Rate limit exceeded"\n}`;
+      const instance = ErrorChunk.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ErrorChunk.fromJson(output);
+      expect(reloaded.message).toEqual(instance.message);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `message: Rate limit exceeded\n`;
+      const instance = ErrorChunk.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.message).toEqual("Rate limit exceeded");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `message: Rate limit exceeded\n`;
+      const instance = ErrorChunk.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ErrorChunk.fromYaml(output);
+      expect(reloaded.message).toEqual(instance.message);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ErrorChunk.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ErrorChunk();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/error-event-payload.test.ts b/runtime/typescript/packages/core/tests/model/error-event-payload.test.ts
new file mode 100644
index 00000000..bbca5704
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/error-event-payload.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ErrorEventPayload } from "../../src/model/index";
+
+describe("ErrorEventPayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ErrorEventPayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ErrorEventPayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "message": "Rate limit exceeded"\n}`;
+      const instance = ErrorEventPayload.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.message).toEqual("Rate limit exceeded");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "message": "Rate limit exceeded"\n}`;
+      const instance = ErrorEventPayload.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ErrorEventPayload.fromJson(output);
+      expect(reloaded.message).toEqual(instance.message);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `message: Rate limit exceeded\n`;
+      const instance = ErrorEventPayload.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.message).toEqual("Rate limit exceeded");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `message: Rate limit exceeded\n`;
+      const instance = ErrorEventPayload.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ErrorEventPayload.fromYaml(output);
+      expect(reloaded.message).toEqual(instance.message);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ErrorEventPayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ErrorEventPayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/file-part.test.ts b/runtime/typescript/packages/core/tests/model/file-part.test.ts
new file mode 100644
index 00000000..48b80e8a
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/file-part.test.ts
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { FilePart } from "../../src/model/index";
+
+describe("FilePart", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new FilePart();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new FilePart({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "source": "https://example.com/document.pdf",\n  "mediaType": "application/pdf"\n}`;
+      const instance = FilePart.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.source).toEqual("https://example.com/document.pdf");
+      expect(instance.mediaType).toEqual("application/pdf");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "source": "https://example.com/document.pdf",\n  "mediaType": "application/pdf"\n}`;
+      const instance = FilePart.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = FilePart.fromJson(output);
+      expect(reloaded.source).toEqual(instance.source);
+      expect(reloaded.mediaType).toEqual(instance.mediaType);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `source: "https://example.com/document.pdf"\nmediaType: application/pdf\n`;
+      const instance = FilePart.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.source).toEqual("https://example.com/document.pdf");
+      expect(instance.mediaType).toEqual("application/pdf");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `source: "https://example.com/document.pdf"\nmediaType: application/pdf\n`;
+      const instance = FilePart.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = FilePart.fromYaml(output);
+      expect(reloaded.source).toEqual(instance.source);
+      expect(reloaded.mediaType).toEqual(instance.mediaType);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = FilePart.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new FilePart();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/format-config.test.ts b/runtime/typescript/packages/core/tests/model/format-config.test.ts
index 73b453f2..39c34509 100644
--- a/runtime/typescript/packages/core/tests/model/format-config.test.ts
+++ b/runtime/typescript/packages/core/tests/model/format-config.test.ts
@@ -21,9 +21,7 @@ describe("FormatConfig", () => {
       const json = `{\n  "kind": "mustache",\n  "strict": true,\n  "options": {\n    "key": "value"\n  }\n}`;
       const instance = FormatConfig.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("mustache");
-
       expect(instance.strict).toEqual(true);
     });
 
@@ -32,9 +30,7 @@ describe("FormatConfig", () => {
       const instance = FormatConfig.fromJson(json);
       const output = instance.toJson();
       const reloaded = FormatConfig.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.strict).toEqual(instance.strict);
     });
   });
@@ -44,9 +40,7 @@ describe("FormatConfig", () => {
       const yaml = `kind: mustache\nstrict: true\noptions:\n  key: value\n`;
       const instance = FormatConfig.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("mustache");
-
       expect(instance.strict).toEqual(true);
     });
 
@@ -55,9 +49,7 @@ describe("FormatConfig", () => {
       const instance = FormatConfig.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = FormatConfig.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.strict).toEqual(instance.strict);
     });
   });
@@ -68,12 +60,12 @@ describe("FormatConfig", () => {
       const json = JSON.stringify(value);
       const instance = FormatConfig.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("example");
     });
   });
 
   describe("load and save", () => {
+
     it("should save to dictionary", () => {
       const instance = new FormatConfig();
       const data = instance.save();
diff --git a/runtime/typescript/packages/core/tests/model/foundry-connection.test.ts b/runtime/typescript/packages/core/tests/model/foundry-connection.test.ts
index a0c8af38..bb2531ad 100644
--- a/runtime/typescript/packages/core/tests/model/foundry-connection.test.ts
+++ b/runtime/typescript/packages/core/tests/model/foundry-connection.test.ts
@@ -21,15 +21,9 @@ describe("FoundryConnection", () => {
       const json = `{\n  "kind": "foundry",\n  "endpoint": "https://myresource.services.ai.azure.com/api/projects/myproject",\n  "name": "my-openai-connection",\n  "connectionType": "model"\n}`;
       const instance = FoundryConnection.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("foundry");
-
-      expect(instance.endpoint).toEqual(
-        "https://myresource.services.ai.azure.com/api/projects/myproject",
-      );
-
+      expect(instance.endpoint).toEqual("https://myresource.services.ai.azure.com/api/projects/myproject");
       expect(instance.name).toEqual("my-openai-connection");
-
       expect(instance.connectionType).toEqual("model");
     });
 
@@ -38,13 +32,9 @@ describe("FoundryConnection", () => {
       const instance = FoundryConnection.fromJson(json);
       const output = instance.toJson();
       const reloaded = FoundryConnection.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.connectionType).toEqual(instance.connectionType);
     });
   });
@@ -54,15 +44,9 @@ describe("FoundryConnection", () => {
       const yaml = `kind: foundry\nendpoint: "https://myresource.services.ai.azure.com/api/projects/myproject"\nname: my-openai-connection\nconnectionType: model\n`;
       const instance = FoundryConnection.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("foundry");
-
-      expect(instance.endpoint).toEqual(
-        "https://myresource.services.ai.azure.com/api/projects/myproject",
-      );
-
+      expect(instance.endpoint).toEqual("https://myresource.services.ai.azure.com/api/projects/myproject");
       expect(instance.name).toEqual("my-openai-connection");
-
       expect(instance.connectionType).toEqual("model");
     });
 
@@ -71,13 +55,9 @@ describe("FoundryConnection", () => {
       const instance = FoundryConnection.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = FoundryConnection.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.connectionType).toEqual(instance.connectionType);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/function-tool.test.ts b/runtime/typescript/packages/core/tests/model/function-tool.test.ts
index 0d43fa3d..a0fcdf60 100644
--- a/runtime/typescript/packages/core/tests/model/function-tool.test.ts
+++ b/runtime/typescript/packages/core/tests/model/function-tool.test.ts
@@ -21,9 +21,7 @@ describe("FunctionTool", () => {
       const json = `{\n  "kind": "function",\n  "parameters": {\n    "firstName": {\n      "kind": "string",\n      "default": "Jane"\n    },\n    "lastName": {\n      "kind": "string",\n      "default": "Doe"\n    },\n    "question": {\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  },\n  "strict": true\n}`;
       const instance = FunctionTool.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("function");
-
       expect(instance.strict).toEqual(true);
     });
 
@@ -32,19 +30,14 @@ describe("FunctionTool", () => {
       const instance = FunctionTool.fromJson(json);
       const output = instance.toJson();
       const reloaded = FunctionTool.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.strict).toEqual(instance.strict);
     });
-
     it("should load from JSON - example 2", () => {
       const json = `{\n  "kind": "function",\n  "parameters": [\n    {\n      "name": "firstName",\n      "kind": "string",\n      "default": "Jane"\n    },\n    {\n      "name": "lastName",\n      "kind": "string",\n      "default": "Doe"\n    },\n    {\n      "name": "question",\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  ],\n  "strict": true\n}`;
       const instance = FunctionTool.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("function");
-
       expect(instance.strict).toEqual(true);
     });
 
@@ -53,9 +46,7 @@ describe("FunctionTool", () => {
       const instance = FunctionTool.fromJson(json);
       const output = instance.toJson();
       const reloaded = FunctionTool.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.strict).toEqual(instance.strict);
     });
   });
@@ -65,9 +56,7 @@ describe("FunctionTool", () => {
       const yaml = `kind: function\nparameters:\n  firstName:\n    kind: string\n    default: Jane\n  lastName:\n    kind: string\n    default: Doe\n  question:\n    kind: string\n    default: What is the meaning of life?\nstrict: true\n`;
       const instance = FunctionTool.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("function");
-
       expect(instance.strict).toEqual(true);
     });
 
@@ -76,19 +65,14 @@ describe("FunctionTool", () => {
       const instance = FunctionTool.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = FunctionTool.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.strict).toEqual(instance.strict);
     });
-
     it("should load from YAML - example 2", () => {
       const yaml = `kind: function\nparameters:\n  - name: firstName\n    kind: string\n    default: Jane\n  - name: lastName\n    kind: string\n    default: Doe\n  - name: question\n    kind: string\n    default: What is the meaning of life?\nstrict: true\n`;
       const instance = FunctionTool.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("function");
-
       expect(instance.strict).toEqual(true);
     });
 
@@ -97,9 +81,7 @@ describe("FunctionTool", () => {
       const instance = FunctionTool.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = FunctionTool.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.strict).toEqual(instance.strict);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/guardrail-result.test.ts b/runtime/typescript/packages/core/tests/model/guardrail-result.test.ts
new file mode 100644
index 00000000..04ba47b9
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/guardrail-result.test.ts
@@ -0,0 +1,92 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { GuardrailResult } from "../../src/model/index";
+
+describe("GuardrailResult", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new GuardrailResult();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new GuardrailResult({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "allowed": true,\n  "reason": "Content is safe"\n}`;
+      const instance = GuardrailResult.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.allowed).toEqual(true);
+      expect(instance.reason).toEqual("Content is safe");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "allowed": true,\n  "reason": "Content is safe"\n}`;
+      const instance = GuardrailResult.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = GuardrailResult.fromJson(output);
+      expect(reloaded.allowed).toEqual(instance.allowed);
+      expect(reloaded.reason).toEqual(instance.reason);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `allowed: true\nreason: Content is safe\n`;
+      const instance = GuardrailResult.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.allowed).toEqual(true);
+      expect(instance.reason).toEqual("Content is safe");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `allowed: true\nreason: Content is safe\n`;
+      const instance = GuardrailResult.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = GuardrailResult.fromYaml(output);
+      expect(reloaded.allowed).toEqual(instance.allowed);
+      expect(reloaded.reason).toEqual(instance.reason);
+    });
+  });
+
+  describe("factory methods", () => {
+    it("should create instance via rewrite() factory", () => {
+      const instance = GuardrailResult.rewrite("test");
+      expect(instance).toBeDefined();
+      expect(instance).toBeInstanceOf(GuardrailResult);
+      expect(instance.allowed).toBe(true);
+    });
+    it("should create instance via deny() factory", () => {
+      const instance = GuardrailResult.deny("test");
+      expect(instance).toBeDefined();
+      expect(instance).toBeInstanceOf(GuardrailResult);
+      expect(instance.allowed).toBe(false);
+    });
+    it("should create instance via allow() factory", () => {
+      const instance = GuardrailResult.allow();
+      expect(instance).toBeDefined();
+      expect(instance).toBeInstanceOf(GuardrailResult);
+      expect(instance.allowed).toBe(true);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = GuardrailResult.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new GuardrailResult();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/image-part.test.ts b/runtime/typescript/packages/core/tests/model/image-part.test.ts
new file mode 100644
index 00000000..47bf2630
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/image-part.test.ts
@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ImagePart } from "../../src/model/index";
+
+describe("ImagePart", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ImagePart();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ImagePart({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "source": "https://example.com/image.png",\n  "detail": "auto",\n  "mediaType": "image/png"\n}`;
+      const instance = ImagePart.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.source).toEqual("https://example.com/image.png");
+      expect(instance.detail).toEqual("auto");
+      expect(instance.mediaType).toEqual("image/png");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "source": "https://example.com/image.png",\n  "detail": "auto",\n  "mediaType": "image/png"\n}`;
+      const instance = ImagePart.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ImagePart.fromJson(output);
+      expect(reloaded.source).toEqual(instance.source);
+      expect(reloaded.detail).toEqual(instance.detail);
+      expect(reloaded.mediaType).toEqual(instance.mediaType);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `source: "https://example.com/image.png"\ndetail: auto\nmediaType: image/png\n`;
+      const instance = ImagePart.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.source).toEqual("https://example.com/image.png");
+      expect(instance.detail).toEqual("auto");
+      expect(instance.mediaType).toEqual("image/png");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `source: "https://example.com/image.png"\ndetail: auto\nmediaType: image/png\n`;
+      const instance = ImagePart.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ImagePart.fromYaml(output);
+      expect(reloaded.source).toEqual(instance.source);
+      expect(reloaded.detail).toEqual(instance.detail);
+      expect(reloaded.mediaType).toEqual(instance.mediaType);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ImagePart.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ImagePart();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/mcp-approval-mode.test.ts b/runtime/typescript/packages/core/tests/model/mcp-approval-mode.test.ts
index b5a7daab..fd3d4e76 100644
--- a/runtime/typescript/packages/core/tests/model/mcp-approval-mode.test.ts
+++ b/runtime/typescript/packages/core/tests/model/mcp-approval-mode.test.ts
@@ -21,7 +21,6 @@ describe("McpApprovalMode", () => {
       const json = `{\n  "kind": "never",\n  "alwaysRequireApprovalTools": [\n    "operation1"\n  ],\n  "neverRequireApprovalTools": [\n    "operation2"\n  ]\n}`;
       const instance = McpApprovalMode.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("never");
     });
 
@@ -30,7 +29,6 @@ describe("McpApprovalMode", () => {
       const instance = McpApprovalMode.fromJson(json);
       const output = instance.toJson();
       const reloaded = McpApprovalMode.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
     });
   });
@@ -40,7 +38,6 @@ describe("McpApprovalMode", () => {
       const yaml = `kind: never\nalwaysRequireApprovalTools:\n  - operation1\nneverRequireApprovalTools:\n  - operation2\n`;
       const instance = McpApprovalMode.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("never");
     });
 
@@ -49,7 +46,6 @@ describe("McpApprovalMode", () => {
       const instance = McpApprovalMode.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = McpApprovalMode.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
     });
   });
@@ -60,7 +56,6 @@ describe("McpApprovalMode", () => {
       const json = JSON.stringify(value);
       const instance = McpApprovalMode.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("never");
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/mcp-tool.test.ts b/runtime/typescript/packages/core/tests/model/mcp-tool.test.ts
index c7f00dfe..30672a3d 100644
--- a/runtime/typescript/packages/core/tests/model/mcp-tool.test.ts
+++ b/runtime/typescript/packages/core/tests/model/mcp-tool.test.ts
@@ -21,14 +21,9 @@ describe("McpTool", () => {
       const json = `{\n  "kind": "mcp",\n  "connection": {\n    "kind": "reference"\n  },\n  "serverName": "My MCP Server",\n  "serverDescription": "This tool allows access to MCP services.",\n  "approvalMode": {\n    "kind": "always"\n  },\n  "allowedTools": [\n    "operation1",\n    "operation2"\n  ]\n}`;
       const instance = McpTool.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("mcp");
-
       expect(instance.serverName).toEqual("My MCP Server");
-
-      expect(instance.serverDescription).toEqual(
-        "This tool allows access to MCP services.",
-      );
+      expect(instance.serverDescription).toEqual("This tool allows access to MCP services.");
     });
 
     it("should round-trip JSON - example 1", () => {
@@ -36,11 +31,8 @@ describe("McpTool", () => {
       const instance = McpTool.fromJson(json);
       const output = instance.toJson();
       const reloaded = McpTool.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.serverName).toEqual(instance.serverName);
-
       expect(reloaded.serverDescription).toEqual(instance.serverDescription);
     });
   });
@@ -50,14 +42,9 @@ describe("McpTool", () => {
       const yaml = `kind: mcp\nconnection:\n  kind: reference\nserverName: My MCP Server\nserverDescription: This tool allows access to MCP services.\napprovalMode:\n  kind: always\nallowedTools:\n  - operation1\n  - operation2\n`;
       const instance = McpTool.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("mcp");
-
       expect(instance.serverName).toEqual("My MCP Server");
-
-      expect(instance.serverDescription).toEqual(
-        "This tool allows access to MCP services.",
-      );
+      expect(instance.serverDescription).toEqual("This tool allows access to MCP services.");
     });
 
     it("should round-trip YAML - example 1", () => {
@@ -65,11 +52,8 @@ describe("McpTool", () => {
       const instance = McpTool.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = McpTool.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.serverName).toEqual(instance.serverName);
-
       expect(reloaded.serverDescription).toEqual(instance.serverDescription);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/message.test.ts b/runtime/typescript/packages/core/tests/model/message.test.ts
new file mode 100644
index 00000000..3fbb2283
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/message.test.ts
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { Message } from "../../src/model/index";
+
+describe("Message", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new Message();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new Message({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "role": "user",\n  "parts": [\n    {\n      "kind": "text",\n      "value": "Hello!"\n    }\n  ],\n  "metadata": {\n    "source": "user-input"\n  }\n}`;
+      const instance = Message.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.role).toEqual("user");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "role": "user",\n  "parts": [\n    {\n      "kind": "text",\n      "value": "Hello!"\n    }\n  ],\n  "metadata": {\n    "source": "user-input"\n  }\n}`;
+      const instance = Message.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = Message.fromJson(output);
+      expect(reloaded.role).toEqual(instance.role);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `role: user\nparts:\n  - kind: text\n    value: Hello!\nmetadata:\n  source: user-input\n`;
+      const instance = Message.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.role).toEqual("user");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `role: user\nparts:\n  - kind: text\n    value: Hello!\nmetadata:\n  source: user-input\n`;
+      const instance = Message.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = Message.fromYaml(output);
+      expect(reloaded.role).toEqual(instance.role);
+    });
+  });
+
+  describe("factory methods", () => {
+    it("should create instance via assistant() factory", () => {
+      const instance = Message.assistant("test");
+      expect(instance).toBeDefined();
+      expect(instance).toBeInstanceOf(Message);
+      expect(instance.role).toBe("assistant");
+    });
+    it("should create instance via system() factory", () => {
+      const instance = Message.system("test");
+      expect(instance).toBeDefined();
+      expect(instance).toBeInstanceOf(Message);
+      expect(instance.role).toBe("system");
+    });
+    it("should create instance via user() factory", () => {
+      const instance = Message.user("test");
+      expect(instance).toBeDefined();
+      expect(instance).toBeInstanceOf(Message);
+      expect(instance.role).toBe("user");
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = Message.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new Message();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/messages-updated-payload.test.ts b/runtime/typescript/packages/core/tests/model/messages-updated-payload.test.ts
new file mode 100644
index 00000000..0f96c78e
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/messages-updated-payload.test.ts
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { MessagesUpdatedPayload } from "../../src/model/index";
+
+describe("MessagesUpdatedPayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new MessagesUpdatedPayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new MessagesUpdatedPayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = MessagesUpdatedPayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new MessagesUpdatedPayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/model-info.test.ts b/runtime/typescript/packages/core/tests/model/model-info.test.ts
new file mode 100644
index 00000000..30327c8b
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/model-info.test.ts
@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ModelInfo } from "../../src/model/index";
+
+describe("ModelInfo", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ModelInfo();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ModelInfo({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "id": "gpt-4o",\n  "displayName": "GPT-4o",\n  "ownedBy": "openai",\n  "contextWindow": 128000,\n  "inputModalities": [\n    "text",\n    "image"\n  ],\n  "outputModalities": [\n    "text"\n  ],\n  "additionalProperties": {\n    "supportsStreaming": true\n  }\n}`;
+      const instance = ModelInfo.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.id).toEqual("gpt-4o");
+      expect(instance.displayName).toEqual("GPT-4o");
+      expect(instance.ownedBy).toEqual("openai");
+      expect(instance.contextWindow).toEqual(128000);
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "id": "gpt-4o",\n  "displayName": "GPT-4o",\n  "ownedBy": "openai",\n  "contextWindow": 128000,\n  "inputModalities": [\n    "text",\n    "image"\n  ],\n  "outputModalities": [\n    "text"\n  ],\n  "additionalProperties": {\n    "supportsStreaming": true\n  }\n}`;
+      const instance = ModelInfo.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ModelInfo.fromJson(output);
+      expect(reloaded.id).toEqual(instance.id);
+      expect(reloaded.displayName).toEqual(instance.displayName);
+      expect(reloaded.ownedBy).toEqual(instance.ownedBy);
+      expect(reloaded.contextWindow).toEqual(instance.contextWindow);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `id: gpt-4o\ndisplayName: GPT-4o\nownedBy: openai\ncontextWindow: 128000\ninputModalities:\n  - text\n  - image\noutputModalities:\n  - text\nadditionalProperties:\n  supportsStreaming: true\n`;
+      const instance = ModelInfo.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.id).toEqual("gpt-4o");
+      expect(instance.displayName).toEqual("GPT-4o");
+      expect(instance.ownedBy).toEqual("openai");
+      expect(instance.contextWindow).toEqual(128000);
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `id: gpt-4o\ndisplayName: GPT-4o\nownedBy: openai\ncontextWindow: 128000\ninputModalities:\n  - text\n  - image\noutputModalities:\n  - text\nadditionalProperties:\n  supportsStreaming: true\n`;
+      const instance = ModelInfo.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ModelInfo.fromYaml(output);
+      expect(reloaded.id).toEqual(instance.id);
+      expect(reloaded.displayName).toEqual(instance.displayName);
+      expect(reloaded.ownedBy).toEqual(instance.ownedBy);
+      expect(reloaded.contextWindow).toEqual(instance.contextWindow);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ModelInfo.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ModelInfo();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/model-options.test.ts b/runtime/typescript/packages/core/tests/model/model-options.test.ts
index f6891caa..9b5af733 100644
--- a/runtime/typescript/packages/core/tests/model/model-options.test.ts
+++ b/runtime/typescript/packages/core/tests/model/model-options.test.ts
@@ -21,21 +21,13 @@ describe("ModelOptions", () => {
       const json = `{\n  "frequencyPenalty": 0.5,\n  "maxOutputTokens": 2048,\n  "presencePenalty": 0.3,\n  "seed": 42,\n  "temperature": 0.7,\n  "topK": 40,\n  "topP": 0.9,\n  "stopSequences": [\n    "\\n",\n    "###"\n  ],\n  "allowMultipleToolCalls": true,\n  "additionalProperties": {\n    "customProperty": "value",\n    "anotherProperty": "anotherValue"\n  }\n}`;
       const instance = ModelOptions.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.frequencyPenalty).toEqual(0.5);
-
       expect(instance.maxOutputTokens).toEqual(2048);
-
       expect(instance.presencePenalty).toEqual(0.3);
-
       expect(instance.seed).toEqual(42);
-
       expect(instance.temperature).toEqual(0.7);
-
       expect(instance.topK).toEqual(40);
-
       expect(instance.topP).toEqual(0.9);
-
       expect(instance.allowMultipleToolCalls).toEqual(true);
     });
 
@@ -44,24 +36,14 @@ describe("ModelOptions", () => {
       const instance = ModelOptions.fromJson(json);
       const output = instance.toJson();
       const reloaded = ModelOptions.fromJson(output);
-
       expect(reloaded.frequencyPenalty).toEqual(instance.frequencyPenalty);
-
       expect(reloaded.maxOutputTokens).toEqual(instance.maxOutputTokens);
-
       expect(reloaded.presencePenalty).toEqual(instance.presencePenalty);
-
       expect(reloaded.seed).toEqual(instance.seed);
-
       expect(reloaded.temperature).toEqual(instance.temperature);
-
       expect(reloaded.topK).toEqual(instance.topK);
-
       expect(reloaded.topP).toEqual(instance.topP);
-
-      expect(reloaded.allowMultipleToolCalls).toEqual(
-        instance.allowMultipleToolCalls,
-      );
+      expect(reloaded.allowMultipleToolCalls).toEqual(instance.allowMultipleToolCalls);
     });
   });
 
@@ -70,21 +52,13 @@ describe("ModelOptions", () => {
       const yaml = `frequencyPenalty: 0.5\nmaxOutputTokens: 2048\npresencePenalty: 0.3\nseed: 42\ntemperature: 0.7\ntopK: 40\ntopP: 0.9\nstopSequences:\n  - "\\n"\n  - "###"\nallowMultipleToolCalls: true\nadditionalProperties:\n  customProperty: value\n  anotherProperty: anotherValue\n`;
       const instance = ModelOptions.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.frequencyPenalty).toEqual(0.5);
-
       expect(instance.maxOutputTokens).toEqual(2048);
-
       expect(instance.presencePenalty).toEqual(0.3);
-
       expect(instance.seed).toEqual(42);
-
       expect(instance.temperature).toEqual(0.7);
-
       expect(instance.topK).toEqual(40);
-
       expect(instance.topP).toEqual(0.9);
-
       expect(instance.allowMultipleToolCalls).toEqual(true);
     });
 
@@ -93,24 +67,14 @@ describe("ModelOptions", () => {
       const instance = ModelOptions.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = ModelOptions.fromYaml(output);
-
       expect(reloaded.frequencyPenalty).toEqual(instance.frequencyPenalty);
-
       expect(reloaded.maxOutputTokens).toEqual(instance.maxOutputTokens);
-
       expect(reloaded.presencePenalty).toEqual(instance.presencePenalty);
-
       expect(reloaded.seed).toEqual(instance.seed);
-
       expect(reloaded.temperature).toEqual(instance.temperature);
-
       expect(reloaded.topK).toEqual(instance.topK);
-
       expect(reloaded.topP).toEqual(instance.topP);
-
-      expect(reloaded.allowMultipleToolCalls).toEqual(
-        instance.allowMultipleToolCalls,
-      );
+      expect(reloaded.allowMultipleToolCalls).toEqual(instance.allowMultipleToolCalls);
     });
   });
 
diff --git a/runtime/typescript/packages/core/tests/model/model.test.ts b/runtime/typescript/packages/core/tests/model/model.test.ts
index ac0d2b52..c473162a 100644
--- a/runtime/typescript/packages/core/tests/model/model.test.ts
+++ b/runtime/typescript/packages/core/tests/model/model.test.ts
@@ -21,11 +21,8 @@ describe("Model", () => {
       const json = `{\n  "id": "gpt-35-turbo",\n  "provider": "foundry",\n  "apiType": "chat",\n  "connection": {\n    "kind": "key",\n    "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n    "key": "{your-api-key}"\n  },\n  "options": {\n    "type": "chat",\n    "temperature": 0.7,\n    "maxOutputTokens": 1000\n  }\n}`;
       const instance = Model.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.id).toEqual("gpt-35-turbo");
-
       expect(instance.provider).toEqual("foundry");
-
       expect(instance.apiType).toEqual("chat");
     });
 
@@ -34,11 +31,8 @@ describe("Model", () => {
       const instance = Model.fromJson(json);
       const output = instance.toJson();
       const reloaded = Model.fromJson(output);
-
       expect(reloaded.id).toEqual(instance.id);
-
       expect(reloaded.provider).toEqual(instance.provider);
-
       expect(reloaded.apiType).toEqual(instance.apiType);
     });
   });
@@ -48,11 +42,8 @@ describe("Model", () => {
       const yaml = `id: gpt-35-turbo\nprovider: foundry\napiType: chat\nconnection:\n  kind: key\n  endpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n  key: "{your-api-key}"\noptions:\n  type: chat\n  temperature: 0.7\n  maxOutputTokens: 1000\n`;
       const instance = Model.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.id).toEqual("gpt-35-turbo");
-
       expect(instance.provider).toEqual("foundry");
-
       expect(instance.apiType).toEqual("chat");
     });
 
@@ -61,11 +52,8 @@ describe("Model", () => {
       const instance = Model.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Model.fromYaml(output);
-
       expect(reloaded.id).toEqual(instance.id);
-
       expect(reloaded.provider).toEqual(instance.provider);
-
       expect(reloaded.apiType).toEqual(instance.apiType);
     });
   });
@@ -76,7 +64,6 @@ describe("Model", () => {
       const json = JSON.stringify(value);
       const instance = Model.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.id).toEqual("example");
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/o-auth-connection.test.ts b/runtime/typescript/packages/core/tests/model/o-auth-connection.test.ts
index 3ee7ff39..ea480f30 100644
--- a/runtime/typescript/packages/core/tests/model/o-auth-connection.test.ts
+++ b/runtime/typescript/packages/core/tests/model/o-auth-connection.test.ts
@@ -21,18 +21,11 @@ describe("OAuthConnection", () => {
       const json = `{\n  "kind": "oauth",\n  "endpoint": "https://api.example.com",\n  "clientId": "your-client-id",\n  "clientSecret": "your-client-secret",\n  "tokenUrl": "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token",\n  "scopes": [\n    "https://cognitiveservices.azure.com/.default"\n  ]\n}`;
       const instance = OAuthConnection.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("oauth");
-
       expect(instance.endpoint).toEqual("https://api.example.com");
-
       expect(instance.clientId).toEqual("your-client-id");
-
       expect(instance.clientSecret).toEqual("your-client-secret");
-
-      expect(instance.tokenUrl).toEqual(
-        "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token",
-      );
+      expect(instance.tokenUrl).toEqual("https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token");
     });
 
     it("should round-trip JSON - example 1", () => {
@@ -40,15 +33,10 @@ describe("OAuthConnection", () => {
       const instance = OAuthConnection.fromJson(json);
       const output = instance.toJson();
       const reloaded = OAuthConnection.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
-
       expect(reloaded.clientId).toEqual(instance.clientId);
-
       expect(reloaded.clientSecret).toEqual(instance.clientSecret);
-
       expect(reloaded.tokenUrl).toEqual(instance.tokenUrl);
     });
   });
@@ -58,18 +46,11 @@ describe("OAuthConnection", () => {
       const yaml = `kind: oauth\nendpoint: "https://api.example.com"\nclientId: your-client-id\nclientSecret: your-client-secret\ntokenUrl: "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"\nscopes:\n  - "https://cognitiveservices.azure.com/.default"\n`;
       const instance = OAuthConnection.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("oauth");
-
       expect(instance.endpoint).toEqual("https://api.example.com");
-
       expect(instance.clientId).toEqual("your-client-id");
-
       expect(instance.clientSecret).toEqual("your-client-secret");
-
-      expect(instance.tokenUrl).toEqual(
-        "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token",
-      );
+      expect(instance.tokenUrl).toEqual("https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token");
     });
 
     it("should round-trip YAML - example 1", () => {
@@ -77,15 +58,10 @@ describe("OAuthConnection", () => {
       const instance = OAuthConnection.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = OAuthConnection.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
-
       expect(reloaded.clientId).toEqual(instance.clientId);
-
       expect(reloaded.clientSecret).toEqual(instance.clientSecret);
-
       expect(reloaded.tokenUrl).toEqual(instance.tokenUrl);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/open-api-tool.test.ts b/runtime/typescript/packages/core/tests/model/open-api-tool.test.ts
index 1f003bc5..e71df65f 100644
--- a/runtime/typescript/packages/core/tests/model/open-api-tool.test.ts
+++ b/runtime/typescript/packages/core/tests/model/open-api-tool.test.ts
@@ -21,9 +21,7 @@ describe("OpenApiTool", () => {
       const json = `{\n  "kind": "openapi",\n  "connection": {\n    "kind": "reference"\n  },\n  "specification": "./openapi.json"\n}`;
       const instance = OpenApiTool.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("openapi");
-
       expect(instance.specification).toEqual("./openapi.json");
     });
 
@@ -32,9 +30,7 @@ describe("OpenApiTool", () => {
       const instance = OpenApiTool.fromJson(json);
       const output = instance.toJson();
       const reloaded = OpenApiTool.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.specification).toEqual(instance.specification);
     });
   });
@@ -44,9 +40,7 @@ describe("OpenApiTool", () => {
       const yaml = `kind: openapi\nconnection:\n  kind: reference\nspecification: ./openapi.json\n`;
       const instance = OpenApiTool.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("openapi");
-
       expect(instance.specification).toEqual("./openapi.json");
     });
 
@@ -55,9 +49,7 @@ describe("OpenApiTool", () => {
       const instance = OpenApiTool.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = OpenApiTool.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.specification).toEqual(instance.specification);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/parser-config.test.ts b/runtime/typescript/packages/core/tests/model/parser-config.test.ts
index 0c8d2664..c60ddfef 100644
--- a/runtime/typescript/packages/core/tests/model/parser-config.test.ts
+++ b/runtime/typescript/packages/core/tests/model/parser-config.test.ts
@@ -21,7 +21,6 @@ describe("ParserConfig", () => {
       const json = `{\n  "kind": "prompty",\n  "options": {\n    "key": "value"\n  }\n}`;
       const instance = ParserConfig.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("prompty");
     });
 
@@ -30,7 +29,6 @@ describe("ParserConfig", () => {
       const instance = ParserConfig.fromJson(json);
       const output = instance.toJson();
       const reloaded = ParserConfig.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
     });
   });
@@ -40,7 +38,6 @@ describe("ParserConfig", () => {
       const yaml = `kind: prompty\noptions:\n  key: value\n`;
       const instance = ParserConfig.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("prompty");
     });
 
@@ -49,7 +46,6 @@ describe("ParserConfig", () => {
       const instance = ParserConfig.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = ParserConfig.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
     });
   });
@@ -60,12 +56,12 @@ describe("ParserConfig", () => {
       const json = JSON.stringify(value);
       const instance = ParserConfig.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("example");
     });
   });
 
   describe("load and save", () => {
+
     it("should save to dictionary", () => {
       const instance = new ParserConfig();
       const data = instance.save();
diff --git a/runtime/typescript/packages/core/tests/model/prompty-tool.test.ts b/runtime/typescript/packages/core/tests/model/prompty-tool.test.ts
index 70b90509..297bfbe4 100644
--- a/runtime/typescript/packages/core/tests/model/prompty-tool.test.ts
+++ b/runtime/typescript/packages/core/tests/model/prompty-tool.test.ts
@@ -21,11 +21,8 @@ describe("PromptyTool", () => {
       const json = `{\n  "kind": "prompty",\n  "path": "./summarize.prompty",\n  "mode": "single"\n}`;
       const instance = PromptyTool.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("prompty");
-
       expect(instance.path).toEqual("./summarize.prompty");
-
       expect(instance.mode).toEqual("single");
     });
 
@@ -34,11 +31,8 @@ describe("PromptyTool", () => {
       const instance = PromptyTool.fromJson(json);
       const output = instance.toJson();
       const reloaded = PromptyTool.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.path).toEqual(instance.path);
-
       expect(reloaded.mode).toEqual(instance.mode);
     });
   });
@@ -48,11 +42,8 @@ describe("PromptyTool", () => {
       const yaml = `kind: prompty\npath: ./summarize.prompty\nmode: single\n`;
       const instance = PromptyTool.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("prompty");
-
       expect(instance.path).toEqual("./summarize.prompty");
-
       expect(instance.mode).toEqual("single");
     });
 
@@ -61,11 +52,8 @@ describe("PromptyTool", () => {
       const instance = PromptyTool.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = PromptyTool.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.path).toEqual(instance.path);
-
       expect(reloaded.mode).toEqual(instance.mode);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/prompty.test.ts b/runtime/typescript/packages/core/tests/model/prompty.test.ts
index 3649fafa..34f1e3c2 100644
--- a/runtime/typescript/packages/core/tests/model/prompty.test.ts
+++ b/runtime/typescript/packages/core/tests/model/prompty.test.ts
@@ -21,18 +21,10 @@ describe("Prompty", () => {
       const json = `{\n  "name": "basic-prompt",\n  "displayName": "Basic Prompt",\n  "description": "A basic prompt that uses the GPT-3 chat API to answer questions",\n  "metadata": {\n    "authors": [\n      "sethjuarez",\n      "jietong"\n    ],\n    "tags": [\n      "example",\n      "prompt"\n    ]\n  },\n  "inputs": {\n    "firstName": {\n      "kind": "string",\n      "default": "Jane"\n    },\n    "lastName": {\n      "kind": "string",\n      "default": "Doe"\n    },\n    "question": {\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  },\n  "outputs": {\n    "answer": {\n      "kind": "string",\n      "description": "The answer to the user's question."\n    }\n  },\n  "model": {\n    "id": "gpt-35-turbo",\n    "connection": {\n      "kind": "key",\n      "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n      "apiKey": "{your-api-key}"\n    }\n  },\n  "tools": [\n    {\n      "name": "getCurrentWeather",\n      "kind": "function",\n      "description": "Get the current weather in a given location",\n      "parameters": {\n        "location": {\n          "kind": "string",\n          "description": "The city and state, e.g. San Francisco, CA"\n        },\n        "unit": {\n          "kind": "string",\n          "description": "The unit of temperature, e.g. Celsius or Fahrenheit"\n        }\n      }\n    }\n  ],\n  "template": {\n    "format": "mustache",\n    "parser": "prompty"\n  },\n  "instructions": "system:\\nYou are an AI assistant who helps people find information.\\nAs the assistant, you answer questions briefly, succinctly,\\nand in a personable manner using markdown and even add some \\npersonal flair with appropriate emojis.\\n\\n# Customer\\nYou are helping {{firstName}} {{lastName}} to find answers to \\ntheir questions. Use their name to address them in your responses.\\nuser:\\n{{question}}"\n}`;
       const instance = Prompty.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip JSON - example 1", () => {
@@ -40,32 +32,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromJson(json);
       const output = instance.toJson();
       const reloaded = Prompty.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from JSON - example 2", () => {
       const json = `{\n  "name": "basic-prompt",\n  "displayName": "Basic Prompt",\n  "description": "A basic prompt that uses the GPT-3 chat API to answer questions",\n  "metadata": {\n    "authors": [\n      "sethjuarez",\n      "jietong"\n    ],\n    "tags": [\n      "example",\n      "prompt"\n    ]\n  },\n  "inputs": {\n    "firstName": {\n      "kind": "string",\n      "default": "Jane"\n    },\n    "lastName": {\n      "kind": "string",\n      "default": "Doe"\n    },\n    "question": {\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  },\n  "outputs": {\n    "answer": {\n      "kind": "string",\n      "description": "The answer to the user's question."\n    }\n  },\n  "model": {\n    "id": "gpt-35-turbo",\n    "connection": {\n      "kind": "key",\n      "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n      "apiKey": "{your-api-key}"\n    }\n  },\n  "tools": {\n    "getCurrentWeather": {\n      "kind": "function",\n      "description": "Get the current weather in a given location",\n      "parameters": {\n        "location": {\n          "kind": "string",\n          "description": "The city and state, e.g. San Francisco, CA"\n        },\n        "unit": {\n          "kind": "string",\n          "description": "The unit of temperature, e.g. Celsius or Fahrenheit"\n        }\n      }\n    }\n  },\n  "template": {\n    "format": "mustache",\n    "parser": "prompty"\n  },\n  "instructions": "system:\\nYou are an AI assistant who helps people find information.\\nAs the assistant, you answer questions briefly, succinctly,\\nand in a personable manner using markdown and even add some \\npersonal flair with appropriate emojis.\\n\\n# Customer\\nYou are helping {{firstName}} {{lastName}} to find answers to \\ntheir questions. Use their name to address them in your responses.\\nuser:\\n{{question}}"\n}`;
       const instance = Prompty.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip JSON - example 2", () => {
@@ -73,32 +52,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromJson(json);
       const output = instance.toJson();
       const reloaded = Prompty.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from JSON - example 3", () => {
       const json = `{\n  "name": "basic-prompt",\n  "displayName": "Basic Prompt",\n  "description": "A basic prompt that uses the GPT-3 chat API to answer questions",\n  "metadata": {\n    "authors": [\n      "sethjuarez",\n      "jietong"\n    ],\n    "tags": [\n      "example",\n      "prompt"\n    ]\n  },\n  "inputs": {\n    "firstName": {\n      "kind": "string",\n      "default": "Jane"\n    },\n    "lastName": {\n      "kind": "string",\n      "default": "Doe"\n    },\n    "question": {\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  },\n  "outputs": [\n    {\n      "name": "answer",\n      "kind": "string",\n      "description": "The answer to the user's question."\n    }\n  ],\n  "model": {\n    "id": "gpt-35-turbo",\n    "connection": {\n      "kind": "key",\n      "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n      "apiKey": "{your-api-key}"\n    }\n  },\n  "tools": [\n    {\n      "name": "getCurrentWeather",\n      "kind": "function",\n      "description": "Get the current weather in a given location",\n      "parameters": {\n        "location": {\n          "kind": "string",\n          "description": "The city and state, e.g. San Francisco, CA"\n        },\n        "unit": {\n          "kind": "string",\n          "description": "The unit of temperature, e.g. Celsius or Fahrenheit"\n        }\n      }\n    }\n  ],\n  "template": {\n    "format": "mustache",\n    "parser": "prompty"\n  },\n  "instructions": "system:\\nYou are an AI assistant who helps people find information.\\nAs the assistant, you answer questions briefly, succinctly,\\nand in a personable manner using markdown and even add some \\npersonal flair with appropriate emojis.\\n\\n# Customer\\nYou are helping {{firstName}} {{lastName}} to find answers to \\ntheir questions. Use their name to address them in your responses.\\nuser:\\n{{question}}"\n}`;
       const instance = Prompty.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip JSON - example 3", () => {
@@ -106,32 +72,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromJson(json);
       const output = instance.toJson();
       const reloaded = Prompty.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from JSON - example 4", () => {
       const json = `{\n  "name": "basic-prompt",\n  "displayName": "Basic Prompt",\n  "description": "A basic prompt that uses the GPT-3 chat API to answer questions",\n  "metadata": {\n    "authors": [\n      "sethjuarez",\n      "jietong"\n    ],\n    "tags": [\n      "example",\n      "prompt"\n    ]\n  },\n  "inputs": {\n    "firstName": {\n      "kind": "string",\n      "default": "Jane"\n    },\n    "lastName": {\n      "kind": "string",\n      "default": "Doe"\n    },\n    "question": {\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  },\n  "outputs": [\n    {\n      "name": "answer",\n      "kind": "string",\n      "description": "The answer to the user's question."\n    }\n  ],\n  "model": {\n    "id": "gpt-35-turbo",\n    "connection": {\n      "kind": "key",\n      "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n      "apiKey": "{your-api-key}"\n    }\n  },\n  "tools": {\n    "getCurrentWeather": {\n      "kind": "function",\n      "description": "Get the current weather in a given location",\n      "parameters": {\n        "location": {\n          "kind": "string",\n          "description": "The city and state, e.g. San Francisco, CA"\n        },\n        "unit": {\n          "kind": "string",\n          "description": "The unit of temperature, e.g. Celsius or Fahrenheit"\n        }\n      }\n    }\n  },\n  "template": {\n    "format": "mustache",\n    "parser": "prompty"\n  },\n  "instructions": "system:\\nYou are an AI assistant who helps people find information.\\nAs the assistant, you answer questions briefly, succinctly,\\nand in a personable manner using markdown and even add some \\npersonal flair with appropriate emojis.\\n\\n# Customer\\nYou are helping {{firstName}} {{lastName}} to find answers to \\ntheir questions. Use their name to address them in your responses.\\nuser:\\n{{question}}"\n}`;
       const instance = Prompty.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip JSON - example 4", () => {
@@ -139,32 +92,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromJson(json);
       const output = instance.toJson();
       const reloaded = Prompty.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from JSON - example 5", () => {
       const json = `{\n  "name": "basic-prompt",\n  "displayName": "Basic Prompt",\n  "description": "A basic prompt that uses the GPT-3 chat API to answer questions",\n  "metadata": {\n    "authors": [\n      "sethjuarez",\n      "jietong"\n    ],\n    "tags": [\n      "example",\n      "prompt"\n    ]\n  },\n  "inputs": [\n    {\n      "name": "firstName",\n      "kind": "string",\n      "default": "Jane"\n    },\n    {\n      "name": "lastName",\n      "kind": "string",\n      "default": "Doe"\n    },\n    {\n      "name": "question",\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  ],\n  "outputs": {\n    "answer": {\n      "kind": "string",\n      "description": "The answer to the user's question."\n    }\n  },\n  "model": {\n    "id": "gpt-35-turbo",\n    "connection": {\n      "kind": "key",\n      "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n      "apiKey": "{your-api-key}"\n    }\n  },\n  "tools": [\n    {\n      "name": "getCurrentWeather",\n      "kind": "function",\n      "description": "Get the current weather in a given location",\n      "parameters": {\n        "location": {\n          "kind": "string",\n          "description": "The city and state, e.g. San Francisco, CA"\n        },\n        "unit": {\n          "kind": "string",\n          "description": "The unit of temperature, e.g. Celsius or Fahrenheit"\n        }\n      }\n    }\n  ],\n  "template": {\n    "format": "mustache",\n    "parser": "prompty"\n  },\n  "instructions": "system:\\nYou are an AI assistant who helps people find information.\\nAs the assistant, you answer questions briefly, succinctly,\\nand in a personable manner using markdown and even add some \\npersonal flair with appropriate emojis.\\n\\n# Customer\\nYou are helping {{firstName}} {{lastName}} to find answers to \\ntheir questions. Use their name to address them in your responses.\\nuser:\\n{{question}}"\n}`;
       const instance = Prompty.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip JSON - example 5", () => {
@@ -172,32 +112,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromJson(json);
       const output = instance.toJson();
       const reloaded = Prompty.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from JSON - example 6", () => {
       const json = `{\n  "name": "basic-prompt",\n  "displayName": "Basic Prompt",\n  "description": "A basic prompt that uses the GPT-3 chat API to answer questions",\n  "metadata": {\n    "authors": [\n      "sethjuarez",\n      "jietong"\n    ],\n    "tags": [\n      "example",\n      "prompt"\n    ]\n  },\n  "inputs": [\n    {\n      "name": "firstName",\n      "kind": "string",\n      "default": "Jane"\n    },\n    {\n      "name": "lastName",\n      "kind": "string",\n      "default": "Doe"\n    },\n    {\n      "name": "question",\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  ],\n  "outputs": {\n    "answer": {\n      "kind": "string",\n      "description": "The answer to the user's question."\n    }\n  },\n  "model": {\n    "id": "gpt-35-turbo",\n    "connection": {\n      "kind": "key",\n      "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n      "apiKey": "{your-api-key}"\n    }\n  },\n  "tools": {\n    "getCurrentWeather": {\n      "kind": "function",\n      "description": "Get the current weather in a given location",\n      "parameters": {\n        "location": {\n          "kind": "string",\n          "description": "The city and state, e.g. San Francisco, CA"\n        },\n        "unit": {\n          "kind": "string",\n          "description": "The unit of temperature, e.g. Celsius or Fahrenheit"\n        }\n      }\n    }\n  },\n  "template": {\n    "format": "mustache",\n    "parser": "prompty"\n  },\n  "instructions": "system:\\nYou are an AI assistant who helps people find information.\\nAs the assistant, you answer questions briefly, succinctly,\\nand in a personable manner using markdown and even add some \\npersonal flair with appropriate emojis.\\n\\n# Customer\\nYou are helping {{firstName}} {{lastName}} to find answers to \\ntheir questions. Use their name to address them in your responses.\\nuser:\\n{{question}}"\n}`;
       const instance = Prompty.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip JSON - example 6", () => {
@@ -205,32 +132,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromJson(json);
       const output = instance.toJson();
       const reloaded = Prompty.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from JSON - example 7", () => {
       const json = `{\n  "name": "basic-prompt",\n  "displayName": "Basic Prompt",\n  "description": "A basic prompt that uses the GPT-3 chat API to answer questions",\n  "metadata": {\n    "authors": [\n      "sethjuarez",\n      "jietong"\n    ],\n    "tags": [\n      "example",\n      "prompt"\n    ]\n  },\n  "inputs": [\n    {\n      "name": "firstName",\n      "kind": "string",\n      "default": "Jane"\n    },\n    {\n      "name": "lastName",\n      "kind": "string",\n      "default": "Doe"\n    },\n    {\n      "name": "question",\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  ],\n  "outputs": [\n    {\n      "name": "answer",\n      "kind": "string",\n      "description": "The answer to the user's question."\n    }\n  ],\n  "model": {\n    "id": "gpt-35-turbo",\n    "connection": {\n      "kind": "key",\n      "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n      "apiKey": "{your-api-key}"\n    }\n  },\n  "tools": [\n    {\n      "name": "getCurrentWeather",\n      "kind": "function",\n      "description": "Get the current weather in a given location",\n      "parameters": {\n        "location": {\n          "kind": "string",\n          "description": "The city and state, e.g. San Francisco, CA"\n        },\n        "unit": {\n          "kind": "string",\n          "description": "The unit of temperature, e.g. Celsius or Fahrenheit"\n        }\n      }\n    }\n  ],\n  "template": {\n    "format": "mustache",\n    "parser": "prompty"\n  },\n  "instructions": "system:\\nYou are an AI assistant who helps people find information.\\nAs the assistant, you answer questions briefly, succinctly,\\nand in a personable manner using markdown and even add some \\npersonal flair with appropriate emojis.\\n\\n# Customer\\nYou are helping {{firstName}} {{lastName}} to find answers to \\ntheir questions. Use their name to address them in your responses.\\nuser:\\n{{question}}"\n}`;
       const instance = Prompty.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip JSON - example 7", () => {
@@ -238,32 +152,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromJson(json);
       const output = instance.toJson();
       const reloaded = Prompty.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from JSON - example 8", () => {
       const json = `{\n  "name": "basic-prompt",\n  "displayName": "Basic Prompt",\n  "description": "A basic prompt that uses the GPT-3 chat API to answer questions",\n  "metadata": {\n    "authors": [\n      "sethjuarez",\n      "jietong"\n    ],\n    "tags": [\n      "example",\n      "prompt"\n    ]\n  },\n  "inputs": [\n    {\n      "name": "firstName",\n      "kind": "string",\n      "default": "Jane"\n    },\n    {\n      "name": "lastName",\n      "kind": "string",\n      "default": "Doe"\n    },\n    {\n      "name": "question",\n      "kind": "string",\n      "default": "What is the meaning of life?"\n    }\n  ],\n  "outputs": [\n    {\n      "name": "answer",\n      "kind": "string",\n      "description": "The answer to the user's question."\n    }\n  ],\n  "model": {\n    "id": "gpt-35-turbo",\n    "connection": {\n      "kind": "key",\n      "endpoint": "https://{your-custom-endpoint}.openai.azure.com/",\n      "apiKey": "{your-api-key}"\n    }\n  },\n  "tools": {\n    "getCurrentWeather": {\n      "kind": "function",\n      "description": "Get the current weather in a given location",\n      "parameters": {\n        "location": {\n          "kind": "string",\n          "description": "The city and state, e.g. San Francisco, CA"\n        },\n        "unit": {\n          "kind": "string",\n          "description": "The unit of temperature, e.g. Celsius or Fahrenheit"\n        }\n      }\n    }\n  },\n  "template": {\n    "format": "mustache",\n    "parser": "prompty"\n  },\n  "instructions": "system:\\nYou are an AI assistant who helps people find information.\\nAs the assistant, you answer questions briefly, succinctly,\\nand in a personable manner using markdown and even add some \\npersonal flair with appropriate emojis.\\n\\n# Customer\\nYou are helping {{firstName}} {{lastName}} to find answers to \\ntheir questions. Use their name to address them in your responses.\\nuser:\\n{{question}}"\n}`;
       const instance = Prompty.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip JSON - example 8", () => {
@@ -271,13 +172,9 @@ describe("Prompty", () => {
       const instance = Prompty.fromJson(json);
       const output = instance.toJson();
       const reloaded = Prompty.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
   });
@@ -287,18 +184,10 @@ describe("Prompty", () => {
       const yaml = `name: basic-prompt\ndisplayName: Basic Prompt\ndescription: A basic prompt that uses the GPT-3 chat API to answer questions\nmetadata:\n  authors:\n    - sethjuarez\n    - jietong\n  tags:\n    - example\n    - prompt\ninputs:\n  firstName:\n    kind: string\n    default: Jane\n  lastName:\n    kind: string\n    default: Doe\n  question:\n    kind: string\n    default: What is the meaning of life?\noutputs:\n  answer:\n    kind: string\n    description: The answer to the user's question.\nmodel:\n  id: gpt-35-turbo\n  connection:\n    kind: key\n    endpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n    apiKey: "{your-api-key}"\ntools:\n  - name: getCurrentWeather\n    kind: function\n    description: Get the current weather in a given location\n    parameters:\n      location:\n        kind: string\n        description: The city and state, e.g. San Francisco, CA\n      unit:\n        kind: string\n        description: The unit of temperature, e.g. Celsius or Fahrenheit\ntemplate:\n  format: mustache\n  parser: prompty\ninstructions: "system:\n\n  You are an AI assistant who helps people find information.\n\n  As the assistant, you answer questions briefly, succinctly,\n\n  and in a personable manner using markdown and even add some\\ \n\n  personal flair with appropriate emojis.\n\n\n  # Customer\n\n  You are helping {{firstName}} {{lastName}} to find answers to\\ \n\n  their questions. Use their name to address them in your responses.\n\n  user:\n\n  {{question}}"\n`;
       const instance = Prompty.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip YAML - example 1", () => {
@@ -306,32 +195,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Prompty.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from YAML - example 2", () => {
       const yaml = `name: basic-prompt\ndisplayName: Basic Prompt\ndescription: A basic prompt that uses the GPT-3 chat API to answer questions\nmetadata:\n  authors:\n    - sethjuarez\n    - jietong\n  tags:\n    - example\n    - prompt\ninputs:\n  firstName:\n    kind: string\n    default: Jane\n  lastName:\n    kind: string\n    default: Doe\n  question:\n    kind: string\n    default: What is the meaning of life?\noutputs:\n  answer:\n    kind: string\n    description: The answer to the user's question.\nmodel:\n  id: gpt-35-turbo\n  connection:\n    kind: key\n    endpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n    apiKey: "{your-api-key}"\ntools:\n  getCurrentWeather:\n    kind: function\n    description: Get the current weather in a given location\n    parameters:\n      location:\n        kind: string\n        description: The city and state, e.g. San Francisco, CA\n      unit:\n        kind: string\n        description: The unit of temperature, e.g. Celsius or Fahrenheit\ntemplate:\n  format: mustache\n  parser: prompty\ninstructions: "system:\n\n  You are an AI assistant who helps people find information.\n\n  As the assistant, you answer questions briefly, succinctly,\n\n  and in a personable manner using markdown and even add some\\ \n\n  personal flair with appropriate emojis.\n\n\n  # Customer\n\n  You are helping {{firstName}} {{lastName}} to find answers to\\ \n\n  their questions. Use their name to address them in your responses.\n\n  user:\n\n  {{question}}"\n`;
       const instance = Prompty.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip YAML - example 2", () => {
@@ -339,32 +215,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Prompty.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from YAML - example 3", () => {
       const yaml = `name: basic-prompt\ndisplayName: Basic Prompt\ndescription: A basic prompt that uses the GPT-3 chat API to answer questions\nmetadata:\n  authors:\n    - sethjuarez\n    - jietong\n  tags:\n    - example\n    - prompt\ninputs:\n  firstName:\n    kind: string\n    default: Jane\n  lastName:\n    kind: string\n    default: Doe\n  question:\n    kind: string\n    default: What is the meaning of life?\noutputs:\n  - name: answer\n    kind: string\n    description: The answer to the user's question.\nmodel:\n  id: gpt-35-turbo\n  connection:\n    kind: key\n    endpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n    apiKey: "{your-api-key}"\ntools:\n  - name: getCurrentWeather\n    kind: function\n    description: Get the current weather in a given location\n    parameters:\n      location:\n        kind: string\n        description: The city and state, e.g. San Francisco, CA\n      unit:\n        kind: string\n        description: The unit of temperature, e.g. Celsius or Fahrenheit\ntemplate:\n  format: mustache\n  parser: prompty\ninstructions: "system:\n\n  You are an AI assistant who helps people find information.\n\n  As the assistant, you answer questions briefly, succinctly,\n\n  and in a personable manner using markdown and even add some\\ \n\n  personal flair with appropriate emojis.\n\n\n  # Customer\n\n  You are helping {{firstName}} {{lastName}} to find answers to\\ \n\n  their questions. Use their name to address them in your responses.\n\n  user:\n\n  {{question}}"\n`;
       const instance = Prompty.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip YAML - example 3", () => {
@@ -372,32 +235,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Prompty.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from YAML - example 4", () => {
       const yaml = `name: basic-prompt\ndisplayName: Basic Prompt\ndescription: A basic prompt that uses the GPT-3 chat API to answer questions\nmetadata:\n  authors:\n    - sethjuarez\n    - jietong\n  tags:\n    - example\n    - prompt\ninputs:\n  firstName:\n    kind: string\n    default: Jane\n  lastName:\n    kind: string\n    default: Doe\n  question:\n    kind: string\n    default: What is the meaning of life?\noutputs:\n  - name: answer\n    kind: string\n    description: The answer to the user's question.\nmodel:\n  id: gpt-35-turbo\n  connection:\n    kind: key\n    endpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n    apiKey: "{your-api-key}"\ntools:\n  getCurrentWeather:\n    kind: function\n    description: Get the current weather in a given location\n    parameters:\n      location:\n        kind: string\n        description: The city and state, e.g. San Francisco, CA\n      unit:\n        kind: string\n        description: The unit of temperature, e.g. Celsius or Fahrenheit\ntemplate:\n  format: mustache\n  parser: prompty\ninstructions: "system:\n\n  You are an AI assistant who helps people find information.\n\n  As the assistant, you answer questions briefly, succinctly,\n\n  and in a personable manner using markdown and even add some\\ \n\n  personal flair with appropriate emojis.\n\n\n  # Customer\n\n  You are helping {{firstName}} {{lastName}} to find answers to\\ \n\n  their questions. Use their name to address them in your responses.\n\n  user:\n\n  {{question}}"\n`;
       const instance = Prompty.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip YAML - example 4", () => {
@@ -405,32 +255,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Prompty.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from YAML - example 5", () => {
       const yaml = `name: basic-prompt\ndisplayName: Basic Prompt\ndescription: A basic prompt that uses the GPT-3 chat API to answer questions\nmetadata:\n  authors:\n    - sethjuarez\n    - jietong\n  tags:\n    - example\n    - prompt\ninputs:\n  - name: firstName\n    kind: string\n    default: Jane\n  - name: lastName\n    kind: string\n    default: Doe\n  - name: question\n    kind: string\n    default: What is the meaning of life?\noutputs:\n  answer:\n    kind: string\n    description: The answer to the user's question.\nmodel:\n  id: gpt-35-turbo\n  connection:\n    kind: key\n    endpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n    apiKey: "{your-api-key}"\ntools:\n  - name: getCurrentWeather\n    kind: function\n    description: Get the current weather in a given location\n    parameters:\n      location:\n        kind: string\n        description: The city and state, e.g. San Francisco, CA\n      unit:\n        kind: string\n        description: The unit of temperature, e.g. Celsius or Fahrenheit\ntemplate:\n  format: mustache\n  parser: prompty\ninstructions: "system:\n\n  You are an AI assistant who helps people find information.\n\n  As the assistant, you answer questions briefly, succinctly,\n\n  and in a personable manner using markdown and even add some\\ \n\n  personal flair with appropriate emojis.\n\n\n  # Customer\n\n  You are helping {{firstName}} {{lastName}} to find answers to\\ \n\n  their questions. Use their name to address them in your responses.\n\n  user:\n\n  {{question}}"\n`;
       const instance = Prompty.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip YAML - example 5", () => {
@@ -438,32 +275,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Prompty.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from YAML - example 6", () => {
       const yaml = `name: basic-prompt\ndisplayName: Basic Prompt\ndescription: A basic prompt that uses the GPT-3 chat API to answer questions\nmetadata:\n  authors:\n    - sethjuarez\n    - jietong\n  tags:\n    - example\n    - prompt\ninputs:\n  - name: firstName\n    kind: string\n    default: Jane\n  - name: lastName\n    kind: string\n    default: Doe\n  - name: question\n    kind: string\n    default: What is the meaning of life?\noutputs:\n  answer:\n    kind: string\n    description: The answer to the user's question.\nmodel:\n  id: gpt-35-turbo\n  connection:\n    kind: key\n    endpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n    apiKey: "{your-api-key}"\ntools:\n  getCurrentWeather:\n    kind: function\n    description: Get the current weather in a given location\n    parameters:\n      location:\n        kind: string\n        description: The city and state, e.g. San Francisco, CA\n      unit:\n        kind: string\n        description: The unit of temperature, e.g. Celsius or Fahrenheit\ntemplate:\n  format: mustache\n  parser: prompty\ninstructions: "system:\n\n  You are an AI assistant who helps people find information.\n\n  As the assistant, you answer questions briefly, succinctly,\n\n  and in a personable manner using markdown and even add some\\ \n\n  personal flair with appropriate emojis.\n\n\n  # Customer\n\n  You are helping {{firstName}} {{lastName}} to find answers to\\ \n\n  their questions. Use their name to address them in your responses.\n\n  user:\n\n  {{question}}"\n`;
       const instance = Prompty.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip YAML - example 6", () => {
@@ -471,32 +295,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Prompty.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from YAML - example 7", () => {
       const yaml = `name: basic-prompt\ndisplayName: Basic Prompt\ndescription: A basic prompt that uses the GPT-3 chat API to answer questions\nmetadata:\n  authors:\n    - sethjuarez\n    - jietong\n  tags:\n    - example\n    - prompt\ninputs:\n  - name: firstName\n    kind: string\n    default: Jane\n  - name: lastName\n    kind: string\n    default: Doe\n  - name: question\n    kind: string\n    default: What is the meaning of life?\noutputs:\n  - name: answer\n    kind: string\n    description: The answer to the user's question.\nmodel:\n  id: gpt-35-turbo\n  connection:\n    kind: key\n    endpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n    apiKey: "{your-api-key}"\ntools:\n  - name: getCurrentWeather\n    kind: function\n    description: Get the current weather in a given location\n    parameters:\n      location:\n        kind: string\n        description: The city and state, e.g. San Francisco, CA\n      unit:\n        kind: string\n        description: The unit of temperature, e.g. Celsius or Fahrenheit\ntemplate:\n  format: mustache\n  parser: prompty\ninstructions: "system:\n\n  You are an AI assistant who helps people find information.\n\n  As the assistant, you answer questions briefly, succinctly,\n\n  and in a personable manner using markdown and even add some\\ \n\n  personal flair with appropriate emojis.\n\n\n  # Customer\n\n  You are helping {{firstName}} {{lastName}} to find answers to\\ \n\n  their questions. Use their name to address them in your responses.\n\n  user:\n\n  {{question}}"\n`;
       const instance = Prompty.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip YAML - example 7", () => {
@@ -504,32 +315,19 @@ describe("Prompty", () => {
       const instance = Prompty.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Prompty.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
-
     it("should load from YAML - example 8", () => {
       const yaml = `name: basic-prompt\ndisplayName: Basic Prompt\ndescription: A basic prompt that uses the GPT-3 chat API to answer questions\nmetadata:\n  authors:\n    - sethjuarez\n    - jietong\n  tags:\n    - example\n    - prompt\ninputs:\n  - name: firstName\n    kind: string\n    default: Jane\n  - name: lastName\n    kind: string\n    default: Doe\n  - name: question\n    kind: string\n    default: What is the meaning of life?\noutputs:\n  - name: answer\n    kind: string\n    description: The answer to the user's question.\nmodel:\n  id: gpt-35-turbo\n  connection:\n    kind: key\n    endpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n    apiKey: "{your-api-key}"\ntools:\n  getCurrentWeather:\n    kind: function\n    description: Get the current weather in a given location\n    parameters:\n      location:\n        kind: string\n        description: The city and state, e.g. San Francisco, CA\n      unit:\n        kind: string\n        description: The unit of temperature, e.g. Celsius or Fahrenheit\ntemplate:\n  format: mustache\n  parser: prompty\ninstructions: "system:\n\n  You are an AI assistant who helps people find information.\n\n  As the assistant, you answer questions briefly, succinctly,\n\n  and in a personable manner using markdown and even add some\\ \n\n  personal flair with appropriate emojis.\n\n\n  # Customer\n\n  You are helping {{firstName}} {{lastName}} to find answers to\\ \n\n  their questions. Use their name to address them in your responses.\n\n  user:\n\n  {{question}}"\n`;
       const instance = Prompty.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("basic-prompt");
-
       expect(instance.displayName).toEqual("Basic Prompt");
-
-      expect(instance.description).toEqual(
-        "A basic prompt that uses the GPT-3 chat API to answer questions",
-      );
-
-      expect(instance.instructions).toEqual(
-        "system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}",
-      );
+      expect(instance.description).toEqual("A basic prompt that uses the GPT-3 chat API to answer questions");
+      expect(instance.instructions).toEqual("system:\nYou are an AI assistant who helps people find information.\nAs the assistant, you answer questions briefly, succinctly,\nand in a personable manner using markdown and even add some \npersonal flair with appropriate emojis.\n\n# Customer\nYou are helping {{firstName}} {{lastName}} to find answers to \ntheir questions. Use their name to address them in your responses.\nuser:\n{{question}}");
     });
 
     it("should round-trip YAML - example 8", () => {
@@ -537,13 +335,9 @@ describe("Prompty", () => {
       const instance = Prompty.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Prompty.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.displayName).toEqual(instance.displayName);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.instructions).toEqual(instance.instructions);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/property.test.ts b/runtime/typescript/packages/core/tests/model/property.test.ts
index f733f109..4038e563 100644
--- a/runtime/typescript/packages/core/tests/model/property.test.ts
+++ b/runtime/typescript/packages/core/tests/model/property.test.ts
@@ -21,19 +21,11 @@ describe("Property", () => {
       const json = `{\n  "name": "my-input",\n  "kind": "string",\n  "description": "A description of the input property",\n  "required": true,\n  "default": "default value",\n  "example": "example value",\n  "enumValues": [\n    "value1",\n    "value2",\n    "value3"\n  ]\n}`;
       const instance = Property.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("my-input");
-
       expect(instance.kind).toEqual("string");
-
-      expect(instance.description).toEqual(
-        "A description of the input property",
-      );
-
+      expect(instance.description).toEqual("A description of the input property");
       expect(instance.required).toEqual(true);
-
       expect(instance.default).toEqual("default value");
-
       expect(instance.example).toEqual("example value");
     });
 
@@ -42,17 +34,11 @@ describe("Property", () => {
       const instance = Property.fromJson(json);
       const output = instance.toJson();
       const reloaded = Property.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.required).toEqual(instance.required);
-
       expect(reloaded.default).toEqual(instance.default);
-
       expect(reloaded.example).toEqual(instance.example);
     });
   });
@@ -62,19 +48,11 @@ describe("Property", () => {
       const yaml = `name: my-input\nkind: string\ndescription: A description of the input property\nrequired: true\ndefault: default value\nexample: example value\nenumValues:\n  - value1\n  - value2\n  - value3\n`;
       const instance = Property.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("my-input");
-
       expect(instance.kind).toEqual("string");
-
-      expect(instance.description).toEqual(
-        "A description of the input property",
-      );
-
+      expect(instance.description).toEqual("A description of the input property");
       expect(instance.required).toEqual(true);
-
       expect(instance.default).toEqual("default value");
-
       expect(instance.example).toEqual("example value");
     });
 
@@ -83,17 +61,11 @@ describe("Property", () => {
       const instance = Property.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Property.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.description).toEqual(instance.description);
-
       expect(reloaded.required).toEqual(instance.required);
-
       expect(reloaded.default).toEqual(instance.default);
-
       expect(reloaded.example).toEqual(instance.example);
     });
   });
@@ -104,47 +76,37 @@ describe("Property", () => {
       const json = JSON.stringify(value);
       const instance = Property.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("boolean");
-
       expect(instance.example).toEqual(false);
     });
-
     it("should handle input alternate representation", () => {
       const value = 3.14;
       const json = JSON.stringify(value);
       const instance = Property.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("float");
-
       expect(instance.example).toEqual(3.14);
     });
-
     it("should handle input alternate representation", () => {
       const value = 4;
       const json = JSON.stringify(value);
       const instance = Property.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("integer");
-
       expect(instance.example).toEqual(4);
     });
-
     it("should handle input alternate representation", () => {
       const value = "example";
       const json = JSON.stringify(value);
       const instance = Property.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("string");
-
       expect(instance.example).toEqual("example");
     });
   });
 
   describe("load and save", () => {
+
     it("should save to dictionary", () => {
       const instance = new Property();
       const data = instance.save();
diff --git a/runtime/typescript/packages/core/tests/model/reference-connection.test.ts b/runtime/typescript/packages/core/tests/model/reference-connection.test.ts
index 140ab390..d5914b70 100644
--- a/runtime/typescript/packages/core/tests/model/reference-connection.test.ts
+++ b/runtime/typescript/packages/core/tests/model/reference-connection.test.ts
@@ -21,11 +21,8 @@ describe("ReferenceConnection", () => {
       const json = `{\n  "kind": "reference",\n  "name": "my-reference-connection",\n  "target": "my-target-resource"\n}`;
       const instance = ReferenceConnection.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("reference");
-
       expect(instance.name).toEqual("my-reference-connection");
-
       expect(instance.target).toEqual("my-target-resource");
     });
 
@@ -34,11 +31,8 @@ describe("ReferenceConnection", () => {
       const instance = ReferenceConnection.fromJson(json);
       const output = instance.toJson();
       const reloaded = ReferenceConnection.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.target).toEqual(instance.target);
     });
   });
@@ -48,11 +42,8 @@ describe("ReferenceConnection", () => {
       const yaml = `kind: reference\nname: my-reference-connection\ntarget: my-target-resource\n`;
       const instance = ReferenceConnection.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("reference");
-
       expect(instance.name).toEqual("my-reference-connection");
-
       expect(instance.target).toEqual("my-target-resource");
     });
 
@@ -61,11 +52,8 @@ describe("ReferenceConnection", () => {
       const instance = ReferenceConnection.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = ReferenceConnection.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.target).toEqual(instance.target);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/remote-connection.test.ts b/runtime/typescript/packages/core/tests/model/remote-connection.test.ts
index 2f496cdc..18a655d6 100644
--- a/runtime/typescript/packages/core/tests/model/remote-connection.test.ts
+++ b/runtime/typescript/packages/core/tests/model/remote-connection.test.ts
@@ -21,14 +21,9 @@ describe("RemoteConnection", () => {
       const json = `{\n  "kind": "remote",\n  "name": "my-reference-connection",\n  "endpoint": "https://{your-custom-endpoint}.openai.azure.com/"\n}`;
       const instance = RemoteConnection.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("remote");
-
       expect(instance.name).toEqual("my-reference-connection");
-
-      expect(instance.endpoint).toEqual(
-        "https://{your-custom-endpoint}.openai.azure.com/",
-      );
+      expect(instance.endpoint).toEqual("https://{your-custom-endpoint}.openai.azure.com/");
     });
 
     it("should round-trip JSON - example 1", () => {
@@ -36,11 +31,8 @@ describe("RemoteConnection", () => {
       const instance = RemoteConnection.fromJson(json);
       const output = instance.toJson();
       const reloaded = RemoteConnection.fromJson(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
     });
   });
@@ -50,14 +42,9 @@ describe("RemoteConnection", () => {
       const yaml = `kind: remote\nname: my-reference-connection\nendpoint: "https://{your-custom-endpoint}.openai.azure.com/"\n`;
       const instance = RemoteConnection.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.kind).toEqual("remote");
-
       expect(instance.name).toEqual("my-reference-connection");
-
-      expect(instance.endpoint).toEqual(
-        "https://{your-custom-endpoint}.openai.azure.com/",
-      );
+      expect(instance.endpoint).toEqual("https://{your-custom-endpoint}.openai.azure.com/");
     });
 
     it("should round-trip YAML - example 1", () => {
@@ -65,11 +52,8 @@ describe("RemoteConnection", () => {
       const instance = RemoteConnection.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = RemoteConnection.fromYaml(output);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.endpoint).toEqual(instance.endpoint);
     });
   });
diff --git a/runtime/typescript/packages/core/tests/model/status-event-payload.test.ts b/runtime/typescript/packages/core/tests/model/status-event-payload.test.ts
new file mode 100644
index 00000000..c6813d80
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/status-event-payload.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { StatusEventPayload } from "../../src/model/index";
+
+describe("StatusEventPayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new StatusEventPayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new StatusEventPayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "message": "Starting iteration 3"\n}`;
+      const instance = StatusEventPayload.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.message).toEqual("Starting iteration 3");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "message": "Starting iteration 3"\n}`;
+      const instance = StatusEventPayload.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = StatusEventPayload.fromJson(output);
+      expect(reloaded.message).toEqual(instance.message);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `message: Starting iteration 3\n`;
+      const instance = StatusEventPayload.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.message).toEqual("Starting iteration 3");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `message: Starting iteration 3\n`;
+      const instance = StatusEventPayload.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = StatusEventPayload.fromYaml(output);
+      expect(reloaded.message).toEqual(instance.message);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = StatusEventPayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new StatusEventPayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/stream-chunk.test.ts b/runtime/typescript/packages/core/tests/model/stream-chunk.test.ts
new file mode 100644
index 00000000..8212b109
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/stream-chunk.test.ts
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { StreamChunk } from "../../src/model/index";
+
+describe("StreamChunk", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new StreamChunk();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new StreamChunk({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+});
diff --git a/runtime/typescript/packages/core/tests/model/text-chunk.test.ts b/runtime/typescript/packages/core/tests/model/text-chunk.test.ts
new file mode 100644
index 00000000..dbe9c01a
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/text-chunk.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { TextChunk } from "../../src/model/index";
+
+describe("TextChunk", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new TextChunk();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new TextChunk({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "value": "Hello"\n}`;
+      const instance = TextChunk.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.value).toEqual("Hello");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "value": "Hello"\n}`;
+      const instance = TextChunk.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = TextChunk.fromJson(output);
+      expect(reloaded.value).toEqual(instance.value);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `value: Hello\n`;
+      const instance = TextChunk.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.value).toEqual("Hello");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `value: Hello\n`;
+      const instance = TextChunk.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = TextChunk.fromYaml(output);
+      expect(reloaded.value).toEqual(instance.value);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = TextChunk.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new TextChunk();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/text-part.test.ts b/runtime/typescript/packages/core/tests/model/text-part.test.ts
new file mode 100644
index 00000000..cf53fe1a
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/text-part.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { TextPart } from "../../src/model/index";
+
+describe("TextPart", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new TextPart();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new TextPart({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "value": "Hello, world!"\n}`;
+      const instance = TextPart.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.value).toEqual("Hello, world!");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "value": "Hello, world!"\n}`;
+      const instance = TextPart.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = TextPart.fromJson(output);
+      expect(reloaded.value).toEqual(instance.value);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `value: Hello, world!\n`;
+      const instance = TextPart.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.value).toEqual("Hello, world!");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `value: Hello, world!\n`;
+      const instance = TextPart.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = TextPart.fromYaml(output);
+      expect(reloaded.value).toEqual(instance.value);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = TextPart.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new TextPart();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/thinking-chunk.test.ts b/runtime/typescript/packages/core/tests/model/thinking-chunk.test.ts
new file mode 100644
index 00000000..82cf3989
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/thinking-chunk.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ThinkingChunk } from "../../src/model/index";
+
+describe("ThinkingChunk", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ThinkingChunk();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ThinkingChunk({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "value": "Let me consider..."\n}`;
+      const instance = ThinkingChunk.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.value).toEqual("Let me consider...");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "value": "Let me consider..."\n}`;
+      const instance = ThinkingChunk.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ThinkingChunk.fromJson(output);
+      expect(reloaded.value).toEqual(instance.value);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `value: Let me consider...\n`;
+      const instance = ThinkingChunk.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.value).toEqual("Let me consider...");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `value: Let me consider...\n`;
+      const instance = ThinkingChunk.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ThinkingChunk.fromYaml(output);
+      expect(reloaded.value).toEqual(instance.value);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ThinkingChunk.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ThinkingChunk();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/thinking-event-payload.test.ts b/runtime/typescript/packages/core/tests/model/thinking-event-payload.test.ts
new file mode 100644
index 00000000..ab18796d
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/thinking-event-payload.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ThinkingEventPayload } from "../../src/model/index";
+
+describe("ThinkingEventPayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ThinkingEventPayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ThinkingEventPayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "token": "Let me consider..."\n}`;
+      const instance = ThinkingEventPayload.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.token).toEqual("Let me consider...");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "token": "Let me consider..."\n}`;
+      const instance = ThinkingEventPayload.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ThinkingEventPayload.fromJson(output);
+      expect(reloaded.token).toEqual(instance.token);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `token: Let me consider...\n`;
+      const instance = ThinkingEventPayload.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.token).toEqual("Let me consider...");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `token: Let me consider...\n`;
+      const instance = ThinkingEventPayload.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ThinkingEventPayload.fromYaml(output);
+      expect(reloaded.token).toEqual(instance.token);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ThinkingEventPayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ThinkingEventPayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/thread-marker.test.ts b/runtime/typescript/packages/core/tests/model/thread-marker.test.ts
new file mode 100644
index 00000000..05c13a23
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/thread-marker.test.ts
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ThreadMarker } from "../../src/model/index";
+
+describe("ThreadMarker", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ThreadMarker();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ThreadMarker({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "name": "thread",\n  "kind": "thread"\n}`;
+      const instance = ThreadMarker.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.name).toEqual("thread");
+      expect(instance.kind).toEqual("thread");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "name": "thread",\n  "kind": "thread"\n}`;
+      const instance = ThreadMarker.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ThreadMarker.fromJson(output);
+      expect(reloaded.name).toEqual(instance.name);
+      expect(reloaded.kind).toEqual(instance.kind);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `name: thread\nkind: thread\n`;
+      const instance = ThreadMarker.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.name).toEqual("thread");
+      expect(instance.kind).toEqual("thread");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `name: thread\nkind: thread\n`;
+      const instance = ThreadMarker.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ThreadMarker.fromYaml(output);
+      expect(reloaded.name).toEqual(instance.name);
+      expect(reloaded.kind).toEqual(instance.kind);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ThreadMarker.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ThreadMarker();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/token-event-payload.test.ts b/runtime/typescript/packages/core/tests/model/token-event-payload.test.ts
new file mode 100644
index 00000000..9ebe0b7a
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/token-event-payload.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { TokenEventPayload } from "../../src/model/index";
+
+describe("TokenEventPayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new TokenEventPayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new TokenEventPayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "token": "Hello"\n}`;
+      const instance = TokenEventPayload.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.token).toEqual("Hello");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "token": "Hello"\n}`;
+      const instance = TokenEventPayload.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = TokenEventPayload.fromJson(output);
+      expect(reloaded.token).toEqual(instance.token);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `token: Hello\n`;
+      const instance = TokenEventPayload.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.token).toEqual("Hello");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `token: Hello\n`;
+      const instance = TokenEventPayload.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = TokenEventPayload.fromYaml(output);
+      expect(reloaded.token).toEqual(instance.token);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = TokenEventPayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new TokenEventPayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/token-usage.test.ts b/runtime/typescript/packages/core/tests/model/token-usage.test.ts
new file mode 100644
index 00000000..d6fb0916
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/token-usage.test.ts
@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { TokenUsage } from "../../src/model/index";
+
+describe("TokenUsage", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new TokenUsage();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new TokenUsage({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "promptTokens": 150,\n  "completionTokens": 42,\n  "totalTokens": 192\n}`;
+      const instance = TokenUsage.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.promptTokens).toEqual(150);
+      expect(instance.completionTokens).toEqual(42);
+      expect(instance.totalTokens).toEqual(192);
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "promptTokens": 150,\n  "completionTokens": 42,\n  "totalTokens": 192\n}`;
+      const instance = TokenUsage.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = TokenUsage.fromJson(output);
+      expect(reloaded.promptTokens).toEqual(instance.promptTokens);
+      expect(reloaded.completionTokens).toEqual(instance.completionTokens);
+      expect(reloaded.totalTokens).toEqual(instance.totalTokens);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `promptTokens: 150\ncompletionTokens: 42\ntotalTokens: 192\n`;
+      const instance = TokenUsage.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.promptTokens).toEqual(150);
+      expect(instance.completionTokens).toEqual(42);
+      expect(instance.totalTokens).toEqual(192);
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `promptTokens: 150\ncompletionTokens: 42\ntotalTokens: 192\n`;
+      const instance = TokenUsage.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = TokenUsage.fromYaml(output);
+      expect(reloaded.promptTokens).toEqual(instance.promptTokens);
+      expect(reloaded.completionTokens).toEqual(instance.completionTokens);
+      expect(reloaded.totalTokens).toEqual(instance.totalTokens);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = TokenUsage.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new TokenUsage();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/tool-call-start-payload.test.ts b/runtime/typescript/packages/core/tests/model/tool-call-start-payload.test.ts
new file mode 100644
index 00000000..e1a93494
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/tool-call-start-payload.test.ts
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ToolCallStartPayload } from "../../src/model/index";
+
+describe("ToolCallStartPayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ToolCallStartPayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ToolCallStartPayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "name": "get_weather",\n  "arguments": "{\\"city\\": \\"Paris\\"}"\n}`;
+      const instance = ToolCallStartPayload.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.name).toEqual("get_weather");
+      expect(instance.arguments).toEqual("{\"city\": \"Paris\"}");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "name": "get_weather",\n  "arguments": "{\\"city\\": \\"Paris\\"}"\n}`;
+      const instance = ToolCallStartPayload.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ToolCallStartPayload.fromJson(output);
+      expect(reloaded.name).toEqual(instance.name);
+      expect(reloaded.arguments).toEqual(instance.arguments);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `name: get_weather\narguments: "{\\"city\\": \\"Paris\\"}"\n`;
+      const instance = ToolCallStartPayload.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.name).toEqual("get_weather");
+      expect(instance.arguments).toEqual("{\"city\": \"Paris\"}");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `name: get_weather\narguments: "{\\"city\\": \\"Paris\\"}"\n`;
+      const instance = ToolCallStartPayload.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ToolCallStartPayload.fromYaml(output);
+      expect(reloaded.name).toEqual(instance.name);
+      expect(reloaded.arguments).toEqual(instance.arguments);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ToolCallStartPayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ToolCallStartPayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/tool-call.test.ts b/runtime/typescript/packages/core/tests/model/tool-call.test.ts
new file mode 100644
index 00000000..6cfc61b9
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/tool-call.test.ts
@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ToolCall } from "../../src/model/index";
+
+describe("ToolCall", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ToolCall();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ToolCall({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "id": "call_abc123",\n  "name": "get_weather",\n  "arguments": "{\\"city\\": \\"Paris\\"}"\n}`;
+      const instance = ToolCall.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.id).toEqual("call_abc123");
+      expect(instance.name).toEqual("get_weather");
+      expect(instance.arguments).toEqual("{\"city\": \"Paris\"}");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "id": "call_abc123",\n  "name": "get_weather",\n  "arguments": "{\\"city\\": \\"Paris\\"}"\n}`;
+      const instance = ToolCall.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ToolCall.fromJson(output);
+      expect(reloaded.id).toEqual(instance.id);
+      expect(reloaded.name).toEqual(instance.name);
+      expect(reloaded.arguments).toEqual(instance.arguments);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `id: call_abc123\nname: get_weather\narguments: "{\\"city\\": \\"Paris\\"}"\n`;
+      const instance = ToolCall.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.id).toEqual("call_abc123");
+      expect(instance.name).toEqual("get_weather");
+      expect(instance.arguments).toEqual("{\"city\": \"Paris\"}");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `id: call_abc123\nname: get_weather\narguments: "{\\"city\\": \\"Paris\\"}"\n`;
+      const instance = ToolCall.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ToolCall.fromYaml(output);
+      expect(reloaded.id).toEqual(instance.id);
+      expect(reloaded.name).toEqual(instance.name);
+      expect(reloaded.arguments).toEqual(instance.arguments);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ToolCall.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ToolCall();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/tool-chunk.test.ts b/runtime/typescript/packages/core/tests/model/tool-chunk.test.ts
new file mode 100644
index 00000000..51b8c939
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/tool-chunk.test.ts
@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ToolChunk } from "../../src/model/index";
+
+describe("ToolChunk", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ToolChunk();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ToolChunk({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "toolCall": {\n    "id": "call_abc123",\n    "name": "get_weather",\n    "arguments": "{\\"city\\": \\"Paris\\"}"\n  }\n}`;
+      const instance = ToolChunk.fromJson(json);
+      expect(instance).toBeDefined();
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "toolCall": {\n    "id": "call_abc123",\n    "name": "get_weather",\n    "arguments": "{\\"city\\": \\"Paris\\"}"\n  }\n}`;
+      const instance = ToolChunk.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ToolChunk.fromJson(output);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `toolCall:\n  id: call_abc123\n  name: get_weather\n  arguments: "{\\"city\\": \\"Paris\\"}"\n`;
+      const instance = ToolChunk.fromYaml(yaml);
+      expect(instance).toBeDefined();
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `toolCall:\n  id: call_abc123\n  name: get_weather\n  arguments: "{\\"city\\": \\"Paris\\"}"\n`;
+      const instance = ToolChunk.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ToolChunk.fromYaml(output);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ToolChunk.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ToolChunk();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/tool-context.test.ts b/runtime/typescript/packages/core/tests/model/tool-context.test.ts
new file mode 100644
index 00000000..729dbdd2
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/tool-context.test.ts
@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ToolContext } from "../../src/model/index";
+
+describe("ToolContext", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ToolContext();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ToolContext({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "metadata": {\n    "userId": "user-123"\n  }\n}`;
+      const instance = ToolContext.fromJson(json);
+      expect(instance).toBeDefined();
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "metadata": {\n    "userId": "user-123"\n  }\n}`;
+      const instance = ToolContext.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ToolContext.fromJson(output);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `metadata:\n  userId: user-123\n`;
+      const instance = ToolContext.fromYaml(yaml);
+      expect(instance).toBeDefined();
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `metadata:\n  userId: user-123\n`;
+      const instance = ToolContext.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ToolContext.fromYaml(output);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ToolContext.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ToolContext();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/tool-dispatch-result.test.ts b/runtime/typescript/packages/core/tests/model/tool-dispatch-result.test.ts
new file mode 100644
index 00000000..b2dd8e92
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/tool-dispatch-result.test.ts
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ToolDispatchResult } from "../../src/model/index";
+
+describe("ToolDispatchResult", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ToolDispatchResult();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ToolDispatchResult({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "toolCallId": "call_abc123",\n  "name": "get_weather",\n  "result": {\n    "parts": [\n      {\n        "kind": "text",\n        "value": "72°F and sunny"\n      }\n    ]\n  }\n}`;
+      const instance = ToolDispatchResult.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.toolCallId).toEqual("call_abc123");
+      expect(instance.name).toEqual("get_weather");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "toolCallId": "call_abc123",\n  "name": "get_weather",\n  "result": {\n    "parts": [\n      {\n        "kind": "text",\n        "value": "72°F and sunny"\n      }\n    ]\n  }\n}`;
+      const instance = ToolDispatchResult.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ToolDispatchResult.fromJson(output);
+      expect(reloaded.toolCallId).toEqual(instance.toolCallId);
+      expect(reloaded.name).toEqual(instance.name);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `toolCallId: call_abc123\nname: get_weather\nresult:\n  parts:\n    - kind: text\n      value: 72°F and sunny\n`;
+      const instance = ToolDispatchResult.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.toolCallId).toEqual("call_abc123");
+      expect(instance.name).toEqual("get_weather");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `toolCallId: call_abc123\nname: get_weather\nresult:\n  parts:\n    - kind: text\n      value: 72°F and sunny\n`;
+      const instance = ToolDispatchResult.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ToolDispatchResult.fromYaml(output);
+      expect(reloaded.toolCallId).toEqual(instance.toolCallId);
+      expect(reloaded.name).toEqual(instance.name);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ToolDispatchResult.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ToolDispatchResult();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/tool-result-payload.test.ts b/runtime/typescript/packages/core/tests/model/tool-result-payload.test.ts
new file mode 100644
index 00000000..a12fb482
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/tool-result-payload.test.ts
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ToolResultPayload } from "../../src/model/index";
+
+describe("ToolResultPayload", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ToolResultPayload();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ToolResultPayload({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "name": "get_weather",\n  "result": {\n    "parts": [\n      {\n        "kind": "text",\n        "value": "72°F and sunny"\n      }\n    ]\n  }\n}`;
+      const instance = ToolResultPayload.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.name).toEqual("get_weather");
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "name": "get_weather",\n  "result": {\n    "parts": [\n      {\n        "kind": "text",\n        "value": "72°F and sunny"\n      }\n    ]\n  }\n}`;
+      const instance = ToolResultPayload.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ToolResultPayload.fromJson(output);
+      expect(reloaded.name).toEqual(instance.name);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `name: get_weather\nresult:\n  parts:\n    - kind: text\n      value: 72°F and sunny\n`;
+      const instance = ToolResultPayload.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.name).toEqual("get_weather");
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `name: get_weather\nresult:\n  parts:\n    - kind: text\n      value: 72°F and sunny\n`;
+      const instance = ToolResultPayload.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ToolResultPayload.fromYaml(output);
+      expect(reloaded.name).toEqual(instance.name);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ToolResultPayload.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ToolResultPayload();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/tool-result.test.ts b/runtime/typescript/packages/core/tests/model/tool-result.test.ts
new file mode 100644
index 00000000..8fbe4a79
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/tool-result.test.ts
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { ToolResult } from "../../src/model/index";
+
+describe("ToolResult", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new ToolResult();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new ToolResult({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "parts": [\n    {\n      "kind": "text",\n      "value": "72°F and sunny"\n    }\n  ]\n}`;
+      const instance = ToolResult.fromJson(json);
+      expect(instance).toBeDefined();
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "parts": [\n    {\n      "kind": "text",\n      "value": "72°F and sunny"\n    }\n  ]\n}`;
+      const instance = ToolResult.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = ToolResult.fromJson(output);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `parts:\n  - kind: text\n    value: 72°F and sunny\n`;
+      const instance = ToolResult.fromYaml(yaml);
+      expect(instance).toBeDefined();
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `parts:\n  - kind: text\n    value: 72°F and sunny\n`;
+      const instance = ToolResult.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = ToolResult.fromYaml(output);
+    });
+  });
+
+  describe("factory methods", () => {
+    it("should create instance via text() factory", () => {
+      const instance = ToolResult.text("test");
+      expect(instance).toBeDefined();
+      expect(instance).toBeInstanceOf(ToolResult);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = ToolResult.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new ToolResult();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/core/tests/model/tool.test.ts b/runtime/typescript/packages/core/tests/model/tool.test.ts
index 416f855f..17fbb9d9 100644
--- a/runtime/typescript/packages/core/tests/model/tool.test.ts
+++ b/runtime/typescript/packages/core/tests/model/tool.test.ts
@@ -21,11 +21,8 @@ describe("Tool", () => {
       const json = `{\n  "name": "my-tool",\n  "kind": "function",\n  "description": "A description of the tool",\n  "bindings": {\n    "input": "value"\n  }\n}`;
       const instance = Tool.fromJson(json);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("my-tool");
-
       expect(instance.kind).toEqual("function");
-
       expect(instance.description).toEqual("A description of the tool");
     });
 
@@ -34,11 +31,8 @@ describe("Tool", () => {
       const instance = Tool.fromJson(json);
       const output = instance.toJson();
       const reloaded = Tool.fromJson(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.description).toEqual(instance.description);
     });
   });
@@ -48,11 +42,8 @@ describe("Tool", () => {
       const yaml = `name: my-tool\nkind: function\ndescription: A description of the tool\nbindings:\n  input: value\n`;
       const instance = Tool.fromYaml(yaml);
       expect(instance).toBeDefined();
-
       expect(instance.name).toEqual("my-tool");
-
       expect(instance.kind).toEqual("function");
-
       expect(instance.description).toEqual("A description of the tool");
     });
 
@@ -61,12 +52,10 @@ describe("Tool", () => {
       const instance = Tool.fromYaml(yaml);
       const output = instance.toYaml();
       const reloaded = Tool.fromYaml(output);
-
       expect(reloaded.name).toEqual(instance.name);
-
       expect(reloaded.kind).toEqual(instance.kind);
-
       expect(reloaded.description).toEqual(instance.description);
     });
   });
+
 });
diff --git a/runtime/typescript/packages/core/tests/model/turn-options.test.ts b/runtime/typescript/packages/core/tests/model/turn-options.test.ts
new file mode 100644
index 00000000..7a38cbcf
--- /dev/null
+++ b/runtime/typescript/packages/core/tests/model/turn-options.test.ts
@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import { TurnOptions } from "../../src/model/index";
+
+describe("TurnOptions", () => {
+  describe("construction", () => {
+    it("should create a new instance with defaults", () => {
+      const instance = new TurnOptions();
+      expect(instance).toBeDefined();
+    });
+
+    it("should create a new instance with partial initialization", () => {
+      const instance = new TurnOptions({});
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe("JSON serialization", () => {
+    it("should load from JSON - example 1", () => {
+      const json = `{\n  "maxIterations": 10,\n  "maxLlmRetries": 3,\n  "contextBudget": 100000,\n  "parallelToolCalls": true,\n  "raw": false,\n  "turn": 1,\n  "compaction": {\n    "strategy": "summarize"\n  }\n}`;
+      const instance = TurnOptions.fromJson(json);
+      expect(instance).toBeDefined();
+      expect(instance.maxIterations).toEqual(10);
+      expect(instance.maxLlmRetries).toEqual(3);
+      expect(instance.contextBudget).toEqual(100000);
+      expect(instance.parallelToolCalls).toEqual(true);
+      expect(instance.raw).toEqual(false);
+      expect(instance.turn).toEqual(1);
+    });
+
+    it("should round-trip JSON - example 1", () => {
+      const json = `{\n  "maxIterations": 10,\n  "maxLlmRetries": 3,\n  "contextBudget": 100000,\n  "parallelToolCalls": true,\n  "raw": false,\n  "turn": 1,\n  "compaction": {\n    "strategy": "summarize"\n  }\n}`;
+      const instance = TurnOptions.fromJson(json);
+      const output = instance.toJson();
+      const reloaded = TurnOptions.fromJson(output);
+      expect(reloaded.maxIterations).toEqual(instance.maxIterations);
+      expect(reloaded.maxLlmRetries).toEqual(instance.maxLlmRetries);
+      expect(reloaded.contextBudget).toEqual(instance.contextBudget);
+      expect(reloaded.parallelToolCalls).toEqual(instance.parallelToolCalls);
+      expect(reloaded.raw).toEqual(instance.raw);
+      expect(reloaded.turn).toEqual(instance.turn);
+    });
+  });
+
+  describe("YAML serialization", () => {
+    it("should load from YAML - example 1", () => {
+      const yaml = `maxIterations: 10\nmaxLlmRetries: 3\ncontextBudget: 100000\nparallelToolCalls: true\nraw: false\nturn: 1\ncompaction:\n  strategy: summarize\n`;
+      const instance = TurnOptions.fromYaml(yaml);
+      expect(instance).toBeDefined();
+      expect(instance.maxIterations).toEqual(10);
+      expect(instance.maxLlmRetries).toEqual(3);
+      expect(instance.contextBudget).toEqual(100000);
+      expect(instance.parallelToolCalls).toEqual(true);
+      expect(instance.raw).toEqual(false);
+      expect(instance.turn).toEqual(1);
+    });
+
+    it("should round-trip YAML - example 1", () => {
+      const yaml = `maxIterations: 10\nmaxLlmRetries: 3\ncontextBudget: 100000\nparallelToolCalls: true\nraw: false\nturn: 1\ncompaction:\n  strategy: summarize\n`;
+      const instance = TurnOptions.fromYaml(yaml);
+      const output = instance.toYaml();
+      const reloaded = TurnOptions.fromYaml(output);
+      expect(reloaded.maxIterations).toEqual(instance.maxIterations);
+      expect(reloaded.maxLlmRetries).toEqual(instance.maxLlmRetries);
+      expect(reloaded.contextBudget).toEqual(instance.contextBudget);
+      expect(reloaded.parallelToolCalls).toEqual(instance.parallelToolCalls);
+      expect(reloaded.raw).toEqual(instance.raw);
+      expect(reloaded.turn).toEqual(instance.turn);
+    });
+  });
+
+  describe("load and save", () => {
+    it("should load from dictionary", () => {
+      const data: Record<string, unknown> = {};
+      const instance = TurnOptions.load(data);
+      expect(instance).toBeDefined();
+    });
+
+    it("should save to dictionary", () => {
+      const instance = new TurnOptions();
+      const data = instance.save();
+      expect(data).toBeDefined();
+      expect(typeof data).toBe("object");
+    });
+  });
+});
diff --git a/runtime/typescript/packages/openai/src/wire.ts b/runtime/typescript/packages/openai/src/wire.ts
index 710f7400..5d629a37 100644
--- a/runtime/typescript/packages/openai/src/wire.ts
+++ b/runtime/typescript/packages/openai/src/wire.ts
@@ -207,15 +207,7 @@ function buildOptions(agent: Prompty): Record<string, unknown> {
   const opts = agent.model?.options;
   if (!opts) return {};
 
-  const result: Record<string, unknown> = {};
-
-  if (opts.temperature !== undefined) result.temperature = opts.temperature;
-  if (opts.maxOutputTokens !== undefined) result.max_completion_tokens = opts.maxOutputTokens;
-  if (opts.topP !== undefined) result.top_p = opts.topP;
-  if (opts.frequencyPenalty !== undefined) result.frequency_penalty = opts.frequencyPenalty;
-  if (opts.presencePenalty !== undefined) result.presence_penalty = opts.presencePenalty;
-  if (opts.stopSequences !== undefined && opts.stopSequences.length > 0) result.stop = opts.stopSequences;
-  if (opts.seed !== undefined) result.seed = opts.seed;
+  const result = opts.toWire("openai");
 
   // Pass through additionalProperties — but don't overwrite mapped keys
   if (opts.additionalProperties) {
@@ -496,11 +488,7 @@ function buildResponsesOptions(agent: Prompty): Record<string, unknown> {
   const opts = agent.model?.options;
   if (!opts) return {};
 
-  const result: Record<string, unknown> = {};
-
-  if (opts.temperature !== undefined) result.temperature = opts.temperature;
-  if (opts.maxOutputTokens !== undefined) result.max_output_tokens = opts.maxOutputTokens;
-  if (opts.topP !== undefined) result.top_p = opts.topP;
+  const result = opts.toWire("responses");
 
   // Pass through additionalProperties — but don't overwrite mapped keys
   if (opts.additionalProperties) {
diff --git a/schema/emitter/package-lock.json b/schema/emitter/package-lock.json
index 1709d303..5976e0b0 100644
--- a/schema/emitter/package-lock.json
+++ b/schema/emitter/package-lock.json
@@ -1,24 +1,22 @@
 {
-  "name": "agentschema-emitter",
+  "name": "prompty-emitter",
   "version": "0.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "agentschema-emitter",
+      "name": "prompty-emitter",
       "version": "0.2.0",
       "license": "MIT",
       "dependencies": {
-        "nunjucks": "^3.2.4",
         "xml-formatter": "^3.6.7",
         "yaml": "^2.8.1"
       },
       "bin": {
-        "agentschema-generate": "dist/src/cli.js"
+        "prompty-generate": "dist/src/cli.js"
       },
       "devDependencies": {
         "@types/node": "^24.7.0",
-        "@types/nunjucks": "^3.2.6",
         "@typescript-eslint/eslint-plugin": "^8.15.0",
         "@typescript-eslint/parser": "^8.15.0",
         "@typespec/compiler": "latest",
@@ -795,13 +793,6 @@
         "undici-types": "~7.16.0"
       }
     },
-    "node_modules/@types/nunjucks": {
-      "version": "3.2.6",
-      "resolved": "https://registry.npmjs.org/@types/nunjucks/-/nunjucks-3.2.6.tgz",
-      "integrity": "sha512-pHiGtf83na1nCzliuAdq8GowYiXvH5l931xZ0YEHaLMNFgynpEqx+IPStlu7UaDkehfvl01e4x/9Tpwhy7Ue3w==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@types/unist": {
       "version": "2.0.11",
       "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
@@ -1107,12 +1098,6 @@
         "@typespec/compiler": "^1.10.0"
       }
     },
-    "node_modules/a-sync-waterfall": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/a-sync-waterfall/-/a-sync-waterfall-1.0.1.tgz",
-      "integrity": "sha512-RYTOHHdWipFUliRFMCS4X2Yn2X8M87V/OpSqWzKKOGhzqyUxzyVmhHDH9sAvG+ZuQf/TAOFsLCpMw09I1ufUnA==",
-      "license": "MIT"
-    },
     "node_modules/acorn": {
       "version": "8.16.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
@@ -1190,12 +1175,6 @@
       "dev": true,
       "license": "Python-2.0"
     },
-    "node_modules/asap": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz",
-      "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==",
-      "license": "MIT"
-    },
     "node_modules/balanced-match": {
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
@@ -3089,40 +3068,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/nunjucks": {
-      "version": "3.2.4",
-      "resolved": "https://registry.npmjs.org/nunjucks/-/nunjucks-3.2.4.tgz",
-      "integrity": "sha512-26XRV6BhkgK0VOxfbU5cQI+ICFUtMLixv1noZn1tGU38kQH5A5nmmbk/O45xdyBhD1esk47nKrY0mvQpZIhRjQ==",
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "a-sync-waterfall": "^1.0.0",
-        "asap": "^2.0.3",
-        "commander": "^5.1.0"
-      },
-      "bin": {
-        "nunjucks-precompile": "bin/precompile"
-      },
-      "engines": {
-        "node": ">= 6.9.0"
-      },
-      "peerDependencies": {
-        "chokidar": "^3.3.0"
-      },
-      "peerDependenciesMeta": {
-        "chokidar": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/nunjucks/node_modules/commander": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
-      "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 6"
-      }
-    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
diff --git a/schema/emitter/package.json b/schema/emitter/package.json
index 50d6bc02..28f13a5b 100644
--- a/schema/emitter/package.json
+++ b/schema/emitter/package.json
@@ -1,17 +1,17 @@
 {
-  "name": "agentschema-emitter",
+  "name": "prompty-emitter",
   "version": "0.2.0",
   "description": "TypeSpec emitter for generating Prompty runtime libraries",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/microsoft/AgentSchema"
+    "url": "https://github.com/microsoft/prompty"
   },
   "type": "module",
   "main": "dist/src/index.js",
   "tspMain": "src/lib/main.tsp",
   "bin": {
-    "agentschema-generate": "./dist/src/cli.js"
+    "prompty-generate": "./dist/src/cli.js"
   },
   "exports": {
     ".": {
@@ -30,7 +30,7 @@
   "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts",
-    "dist/**/*.njk",
+
     "dist/**/*.json",
     "lib/**/*.tsp",
     "src/lib/*.tsp",
@@ -42,7 +42,7 @@
   },
   "devDependencies": {
     "@types/node": "^24.7.0",
-    "@types/nunjucks": "^3.2.6",
+
     "@typescript-eslint/eslint-plugin": "^8.15.0",
     "@typescript-eslint/parser": "^8.15.0",
     "@typespec/compiler": "latest",
@@ -54,7 +54,7 @@
     "typescript-eslint": "^8.54.0"
   },
   "scripts": {
-    "build": "tsc && cp -r ./src/templates ./dist/src",
+    "build": "tsc",
     "watch": "tsc --watch",
     "generate": "tsp compile ./lib/model/main.tsp --config ./tspconfig.yaml && markdownlint \"../docs/src/**/*.md\" -f -c ./markdown.json",
     "test": "node --test",
@@ -66,7 +66,7 @@
   "private": false,
   "packageManager": "npm@11.5.1+sha512.232e6f5d9e799bcb486920b3e9ba907fdf96e576cf7e8c9446c8162e33a416096a1d37a9e910d9a918f6b1f606791c99bc6bb61ee2569b496ec74af13d0dbd95",
   "dependencies": {
-    "nunjucks": "^3.2.4",
+
     "xml-formatter": "^3.6.7",
     "yaml": "^2.8.1"
   }
diff --git a/schema/emitter/src/cli.ts b/schema/emitter/src/cli.ts
index 71ec198c..38034249 100644
--- a/schema/emitter/src/cli.ts
+++ b/schema/emitter/src/cli.ts
@@ -4,10 +4,10 @@ import { generate, TargetLanguage } from "./generate.js";
 import { parseArgs } from "util";
 
 const HELP = `
-agentschema-generate - Generate Prompty runtime libraries
+prompty-generate - Generate Prompty runtime libraries
 
 Usage:
-  npx agentschema-generate [options]
+  npx prompty-generate [options]
 
 Options:
   -o, --output <dir>       Output directory (required)
@@ -21,16 +21,16 @@ Options:
 
 Examples:
   # Generate all runtimes to ./generated
-  npx agentschema-generate -o ./generated
+  npx prompty-generate -o ./generated
 
   # Generate only Python and C# 
-  npx agentschema-generate -o ./lib -t python,csharp
+  npx prompty-generate -o ./lib -t python,csharp
 
   # Generate AgentDefinition instead of AgentManifest
-  npx agentschema-generate -o ./lib -r Prompty.AgentDefinition
+  npx prompty-generate -o ./lib -r Prompty.AgentDefinition
 
   # Omit specific models
-  npx agentschema-generate -o ./lib --omit AgentManifest,ContainerAgent
+  npx prompty-generate -o ./lib --omit AgentManifest,ContainerAgent
 
 Targets:
   python       Python dataclasses with YAML/JSON serialization
diff --git a/schema/emitter/src/csharp.ts b/schema/emitter/src/csharp.ts
deleted file mode 100644
index 459c7b01..00000000
--- a/schema/emitter/src/csharp.ts
+++ /dev/null
@@ -1,569 +0,0 @@
-import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
-import { EmitTarget, PromptyEmitterOptions } from "./lib.js";
-import { enumerateTypes, PropertyNode, TypeNode } from "./ast.js";
-import { GeneratorOptions, filterNodes } from "./emitter.js";
-import * as nunjucks from "nunjucks";
-import { getCombinations, scalarValue } from "./utilities.js";
-import * as YAML from "yaml";
-import path from "path";
-import { resolve, dirname } from "path";
-import { execSync } from "child_process";
-import { existsSync, readdirSync } from "fs";
-
-const csharpTypeMapper: Record<string, string> = {
-  "string": "string",
-  "number": "float",
-  "array": "[]",
-  "object": "object",
-  "boolean": "bool",
-  "int64": "long",
-  "int32": "int",
-  "float64": "double",
-  "float32": "float",
-  "integer": "int",
-  "dictionary": "IDictionary<string, object>",
-};
-
-// Maps C# types to Convert.ToXXX method suffixes
-const convertMethodMapper: Record<string, string> = {
-  "bool": "Boolean",
-  "int": "Int32",
-  "long": "Int64",
-  "float": "Single",
-  "double": "Double",
-};
-
-const jsonConverterMapper: Record<string, string> = {
-  "string": "GetString",
-  // this is smarter about numbers
-  "number": "GetScalarValue",
-  "unknown": "GetScalarValue",
-  "boolean": "GetBoolean",
-  "int64": "GetInt64",
-  "int32": "GetInt32",
-  "float64": "GetDouble",
-  "float32": "GetSingle",
-  "integer": "GetInt32",
-};
-
-const numberTypes = [
-  "float32",
-  "float64",
-  "number",
-  "int32",
-  "int64",
-  "numeric",
-  "integer",
-  "float",
-]
-
-export const generateCsharp = async (context: EmitContext<PromptyEmitterOptions>, templateDir: string, node: TypeNode, emitTarget: EmitTarget, options?: GeneratorOptions) => {
-  // set up template environment
-  const templatePath = path.resolve(templateDir, 'csharp');
-  const env = new nunjucks.Environment(new nunjucks.FileSystemLoader(templatePath));
-  env.addFilter('isFloat', function (value: any) {
-    const isFloat = value.toString().includes('.');
-    return isFloat;
-  });
-  const classTemplate = env.getTemplate('file.cs.njk', true);
-  const utilsTemplate = env.getTemplate('utils.cs.njk', true);
-  const testTemplate = env.getTemplate('test.cs.njk', true);
-  const contextTemplate = env.getTemplate('context.cs.njk', true);
-
-  const nodes = filterNodes(Array.from(enumerateTypes(node)), options);
-
-  // Determine namespace: use explicit override from config, or fall back to TypeSpec namespace
-  const originalNamespace = node.typeName.namespace;
-  const csharpNamespace = emitTarget.namespace ?? originalNamespace;
-
-  // Emit context classes (LoadContext, SaveContext)
-  const contextCode = contextTemplate.render({
-    namespace: csharpNamespace,
-  });
-  await emitCsharpFile(context, node, contextCode, "Context.cs", emitTarget["output-dir"]);
-
-  const utils = utilsTemplate.render({
-    namespace: csharpNamespace,
-  });
-
-  await emitCsharpFile(context, node, utils, "Utils.cs", emitTarget["output-dir"]);
-
-  for (const n of nodes) {
-    await emitCsharpFile(context, n, renderCSharp(nodes, n, classTemplate, csharpNamespace), `${n.typeName.name}.cs`, emitTarget["output-dir"]);
-    if (emitTarget["test-dir"]) {
-      await emitCsharpFile(context, n, renderTests(n, testTemplate, csharpNamespace), `${n.typeName.name}ConversionTests.cs`, emitTarget["test-dir"]);
-    }
-  }
-
-  // Format emitted files if format option is enabled (default: true)
-  if (emitTarget.format !== false) {
-    const outputDir = emitTarget["output-dir"]
-      ? resolve(process.cwd(), emitTarget["output-dir"])
-      : context.emitterOutputDir;
-    const testDir = emitTarget["test-dir"]
-      ? resolve(process.cwd(), emitTarget["test-dir"])
-      : undefined;
-
-    formatCSharpFiles(outputDir, testDir);
-  }
-};
-
-
-const renderCSharp = (nodes: TypeNode[], node: TypeNode, classTemplate: nunjucks.Template, namespace: string): string => {
-  const polymorphicTypes = node.retrievePolymorphicTypes();
-  const findType = (typeName: string): TypeNode | undefined => {
-    return nodes.find(n => n.typeName.name === typeName);
-  }
-  const alternates = generateAlternates(node).filter(alt => alt.scalar !== "float" && alt.scalar !== "int");
-  const numericAlternates = generateAlternates(node).filter(alt => alt.scalar === "float" || alt.scalar === "int");
-
-  // Separate int and float alternates for proper long/double mapping
-  const intAlternate = numericAlternates.find(alt => alt.scalar === "int") || null;
-  const floatAlternate = numericAlternates.find(alt => alt.scalar === "float") || null;
-
-  // Determine shorthand property (first property in first alternate expansion)
-  let shorthandProperty: string | null = null;
-  if (node.alternates && node.alternates.length > 0) {
-    const firstAlt = node.alternates[0];
-    if (firstAlt.expansion) {
-      const keys = Object.keys(firstAlt.expansion);
-      // Find the key that uses {value}
-      for (const key of keys) {
-        if (firstAlt.expansion[key] === "{value}") {
-          shorthandProperty = key;
-          break;
-        }
-      }
-    }
-  }
-
-  // Collection types with their primary property for shorthand
-  // Filter out dictionary collections since they don't have Load methods
-  const collectionTypes = node.properties.filter(p => p.isCollection && !p.isScalar && !p.isDict).map(p => {
-    const itemType = findType(p.typeName.name);
-    let primaryProp: string | null = null;
-    let hasNameProperty = false;
-
-    if (itemType) {
-      // Check if item type has a 'name' property (supports object format)
-      hasNameProperty = itemType.properties.some(prop => prop.name === "name");
-
-      if (itemType.alternates && itemType.alternates.length > 0) {
-        const firstAlt = itemType.alternates[0];
-        if (firstAlt.expansion) {
-          for (const key of Object.keys(firstAlt.expansion)) {
-            if (firstAlt.expansion[key] === "{value}") {
-              primaryProp = key;
-              break;
-            }
-          }
-        }
-      }
-    }
-    return {
-      prop: p,
-      type: primaryProp ? [primaryProp] : [],
-      hasNameProperty: hasNameProperty,
-    };
-  });
-
-  const csharp = classTemplate.render({
-    node: node,
-    renderPropertyName: renderPropertyName,
-    renderName: renderName,
-    renderType: renderType,
-    renderSimpleType: renderSimpleType,
-    renderDefault: renderDefault,
-    renderSetInstance: renderSetInstance,
-    renderSummary: renderSummary,
-    renderPropertyModifier: renderPropertyModifier(findType, node),
-    renderNullCoalescing: renderNullCoalescing,
-    renderLoadProperty: renderLoadProperty(findType),
-    renderSaveProperty: renderSaveProperty,
-    converterMapper: (s: string) => jsonConverterMapper[s] || `Get${s.charAt(0).toUpperCase() + s.slice(1)}`,
-    polymorphicTypes: polymorphicTypes,
-    collectionTypes: collectionTypes,
-    alternates: alternates,
-    numericAlternates: numericAlternates,
-    intAlternate: intAlternate,
-    floatAlternate: floatAlternate,
-    shorthandProperty: shorthandProperty,
-    namespace: namespace,
-  });
-
-  return csharp;
-}
-
-const renderTests = (node: TypeNode, testTemplate: nunjucks.Template, namespace: string): string => {
-  const samples = node.properties.filter(p => p.samples && p.samples.length > 0).map(p => {
-    return p.samples?.map(s => ({
-      ...s.sample,
-    }));
-  });
-
-  const combinations =
-    samples.length > 0 ?
-      getCombinations(samples) :
-      [];
-
-  const examples = combinations.map(c => {
-    const sample = Object.assign({}, ...c);
-    // Create YAML document and customize string scalar style for values with special chars
-    const doc = new YAML.Document(sample);
-    YAML.visit(doc, {
-      Scalar(key, node) {
-        // Only quote string values that contain special characters requiring escaping
-        if (typeof node.value === 'string') {
-          const str = node.value as string;
-          if (str.includes('\n') || str.includes('\t') || str.includes('#') || str.includes(':') || str.includes('"')) {
-            node.type = 'QUOTE_DOUBLE';
-          }
-        }
-      }
-    });
-    return {
-      json: JSON.stringify(sample, null, 2).split('\n'),
-      yaml: doc.toString({ indent: 2, lineWidth: 0 }).split('\n'),
-      // get all scalars in the sample - using 'validations' (plural) for consistency across languages
-      validations: Object.keys(sample).filter(key => typeof sample[key] !== 'object').map(key => ({
-        key: renderName(key),
-        value: typeof sample[key] === 'boolean' ? (sample[key] ? "True" : "False") : sample[key],
-        startDelim: typeof sample[key] === 'string' ? (sample[key].includes('\n') ? '@"' : '"') : '',
-        endDelim: typeof sample[key] === 'string' ? (sample[key].includes('\n') ? '"' : '"') :
-          typeof sample[key] === 'number' && !Number.isInteger(sample[key]) ? 'f' : '',
-      })),
-    };
-  });
-
-  const alternates = node.alternates.map(alt => {
-    const example = alt.example ? (typeof (alt.example) === "string" ? '"' + alt.example + '"' : alt.example.toString()) : scalarValue[alt.scalar] || "None";
-    return {
-      title: alt.title || alt.scalar,
-      scalar: alt.scalar,
-      value: example,
-      // using 'validations' (plural) for consistency across languages
-      validations: Object.keys(alt.expansion).filter(key => typeof alt.expansion[key] !== 'object').map(key => {
-        const value = alt.expansion[key] === "{value}" ? example : alt.expansion[key];
-        return {
-          key: renderName(key),
-          value: value,
-          delimiter: typeof value === 'string' && !value.includes('"') && alt.expansion[key] !== "{value}" ? '"' : '',
-        };
-      }),
-    };
-  });
-
-  const test = testTemplate.render({
-    node: node,
-    // replace control characters in samples
-    examples: examples,
-    alternates: alternates,
-    renderName: renderName,
-    namespace: namespace,
-  });
-  return test;
-};
-
-const renderPropertyName = (prop: PropertyNode): string => {
-  return renderName(prop.name);
-};
-
-const renderName = (name: string): string => {
-  // convert snake_case to PascalCase
-  const pascal = name.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-  // capitalize the first letter
-  return pascal.charAt(0).toUpperCase() + pascal.slice(1);
-};
-
-/**
- * Renders the property modifier for a given property (e.g. override, virtual or even nothing)
- * @param node TypeNode
- * @returns function that takes a PropertyNode and returns the property modifier string
- */
-const renderPropertyModifier = (findType: (typeName: string) => TypeNode | undefined, node: TypeNode) => (prop: PropertyNode): string => {
-  // has children and children have the same property name - need to make virtual
-  if (node.childTypes.length > 0 && node.childTypes.some(ct => ct.properties.some(p => p.name === prop.name))) {
-    // if the property is required and is a complex type, make it virtual to allow for mocking
-    return "virtual ";
-  }
-  // has a parent and parent has the same property name - need to override
-  if (node.base && findType(node.base.name)?.properties.some(p => p.name === prop.name)) {
-    return "override ";
-  }
-  return "";
-};
-
-const recursiveExpand = (obj: any): any => {
-  if (obj && typeof obj === 'object') {
-    if (Array.isArray(obj)) {
-      return obj.map(item => recursiveExpand(item));
-    } else {
-      const expanded: any = {};
-      for (const key in obj) {
-        expanded[key] = recursiveExpand(obj[key]);
-      }
-      return expanded;
-    }
-  }
-  return obj;
-};
-
-const generateAlternates = (node: TypeNode): { scalar: string; expansion: { property: string, value: string }[] }[] => {
-  if (node.alternates && node.alternates.length > 0) {
-    const alternates: { scalar: string; expansion: { property: string, value: string }[] }[] = [];
-    for (const alt of node.alternates) {
-      const scalar = csharpTypeMapper[alt.scalar] || "object";
-
-      // Process each alternate
-      const expansion: { property: string, value: string }[] = [];
-      for (const key in alt.expansion) {
-        const value = alt.expansion[key];
-        // check if value is a string
-        if (value === "{value}") {
-          expansion.push({ property: renderName(key), value: `${scalar}Value` });
-        } else {
-          if (typeof value === 'string') {
-            expansion.push({ property: renderName(key), value: `"${value}"` });
-          } else {
-            expansion.push({ property: renderName(key), value: `${value}` });
-          }
-        }
-      }
-      alternates.push({
-        scalar: scalar,
-        expansion: expansion,
-      });
-    }
-    return alternates;
-  } else {
-    return [];
-  }
-};
-
-const isNonNullableValueType = (typeName: string): boolean => {
-  return ["int", "float", "double", "bool"].includes(typeName);
-};
-
-const renderType = (prop: PropertyNode, removeOptional: boolean = false): string => {
-  return `${renderSimpleType(prop)}${prop.isOptional && !removeOptional ? "?" : ""}`;
-};
-
-const renderSimpleType = (prop: PropertyNode): string => {
-  let type = prop.isScalar ? csharpTypeMapper[prop.typeName.name] || "object" : prop.typeName.name;
-  if (prop.isDict) {
-    type = `IDictionary<string, object>`;
-  }
-  type = prop.isCollection ? `IList<${type}>` : type;
-  return type;
-};
-
-const renderDefault = (prop: PropertyNode): string => {
-  if (!prop.isOptional) {
-    if (prop.isCollection) {
-      return " = [];";
-    } else if (prop.isScalar) {
-      return renderDefaultType(prop.typeName.name, prop.defaultValue);
-    } else {
-      //if (!prop.type?.isAbstract) {
-      //  return " = new " + prop.typeName.name + "();";
-      //}
-      return "";
-    }
-  } else {
-    return "";
-  }
-};
-
-const renderDefaultType = (typeName: string, defaultValue: string | number | boolean | null = null): string => {
-  if (typeName === "string") {
-    if (defaultValue && defaultValue === "*") {
-      return " = string.Empty;";
-    }
-    return defaultValue ? " = \"" + defaultValue + "\";" : " = string.Empty;";
-  }
-  if (typeName === "boolean") {
-    return defaultValue ? " = " + defaultValue + ";" : " = false;";
-  }
-  if (typeName === "number") {
-    return defaultValue ? " = " + defaultValue + ";" : " = 0;";
-  }
-  if (typeName === "object") {
-    return " = new " + typeName + "();";
-  }
-  if (typeName === "dictionary") {
-    return " = new Dictionary<string, object>();";
-  }
-  return "";
-};
-
-const renderSetInstance = (prop: PropertyNode, variable: string, dictArg: string): string => {
-  const propertyName = renderPropertyName(prop);
-  const propertyType = renderSimpleType(prop);
-  const setter = `${variable}.${propertyName}`;
-  if (prop.isScalar) {
-    if (isNonNullableValueType(propertyType)) {
-      return `${setter} = (${propertyType})${prop.name}Value;`;
-    } else {
-      return `${setter} = ${prop.name}Value as ${propertyType}${renderNullCoalescing(prop)};`;
-    }
-  } else {
-    if (prop.isCollection) {
-      return `${setter} = Load${propertyName}(${prop.name}Value);`;
-    } else {
-      return `${setter} = ${prop.typeName.name}.Load(${prop.name}Value.ToParamDictionary());`;
-    }
-  }
-}
-
-/**
- * Renders the property loading code for the Load() method
- */
-const renderLoadProperty = (findType: (typeName: string) => TypeNode | undefined) => (prop: PropertyNode): string => {
-  const propertyName = renderPropertyName(prop);
-  const propertyType = renderSimpleType(prop);
-
-  if (prop.isScalar) {
-    if (prop.isDict) {
-      if (prop.isCollection) {
-        // Dictionary collection - convert each item to proper dictionary type
-        return `instance.${propertyName} = (${prop.name}Value as IEnumerable<object>)?.Select(x => x.GetDictionary()).Cast<IDictionary<string, object>>().ToList() ?? [];`;
-      }
-      return `instance.${propertyName} = ${prop.name}Value.GetDictionary()!;`;
-    }
-    const csharpType = csharpTypeMapper[prop.typeName.name] || "object";
-
-    // Handle scalar collections (e.g., IList<string>)
-    if (prop.isCollection) {
-      if (csharpType === "string") {
-        return `instance.${propertyName} = (${prop.name}Value as IEnumerable<object>)?.Select(x => x?.ToString()!).ToList() ?? [];`;
-      } else if (isNonNullableValueType(csharpType)) {
-        const convertMethod = convertMethodMapper[csharpType] || "ToString";
-        return `instance.${propertyName} = (${prop.name}Value as IEnumerable<object>)?.Select(x => Convert.To${convertMethod}(x)).ToList() ?? [];`;
-      } else {
-        return `instance.${propertyName} = (${prop.name}Value as IEnumerable<object>)?.ToList() ?? [];`;
-      }
-    }
-
-    if (isNonNullableValueType(csharpType)) {
-      const convertMethod = convertMethodMapper[csharpType] || "ToString";
-      return `instance.${propertyName} = Convert.To${convertMethod}(${prop.name}Value);`;
-    } else if (csharpType === "string") {
-      return `instance.${propertyName} = ${prop.name}Value?.ToString()!;`;
-    } else {
-      return `instance.${propertyName} = ${prop.name}Value;`;
-    }
-  } else if (prop.isCollection) {
-    if (prop.isDict) {
-      // Dictionary collection - convert each item to proper dictionary type
-      return `instance.${propertyName} = (${prop.name}Value as IEnumerable<object>)?.Select(x => x.GetDictionary()).Cast<IDictionary<string, object>>().ToList() ?? [];`;
-    }
-    return `instance.${propertyName} = Load${propertyName}(${prop.name}Value, context);`;
-  } else {
-    return `instance.${propertyName} = ${prop.typeName.name}.Load(${prop.name}Value.GetDictionary(${prop.typeName.name}.ShorthandProperty), context);`;
-  }
-};
-
-/**
- * Renders the property saving code for the Save() method
- */
-const renderSaveProperty = (prop: PropertyNode): string => {
-  const propertyName = renderPropertyName(prop);
-
-  if (prop.isScalar || prop.isDict) {
-    return `result["${prop.name}"] = obj.${propertyName};`;
-  } else if (prop.isCollection) {
-    return `result["${prop.name}"] = Save${propertyName}(obj.${propertyName}, context);`;
-  } else {
-    return `result["${prop.name}"] = obj.${propertyName}?.Save(context);`;
-  }
-};
-
-const renderSummary = (prop: PropertyNode): string => {
-  return "/// <summary>\n    /// " + prop.description + "\n    /// </summary>";
-};
-
-const renderNullCoalescing = (prop: PropertyNode): string => {
-  if (!prop.isOptional && !isNumber(prop)) {
-    return " ?? throw new ArgumentException(\"Properties must contain a property named: " + prop.name + "\")";
-  }
-  return "";
-};
-
-const isNumber = (prop: PropertyNode): boolean => {
-  return numberTypes.includes(prop.typeName.name);
-};
-
-const emitCsharpFile = async (context: EmitContext<PromptyEmitterOptions>, type: TypeNode, python: string, filename: string, outputDir?: string) => {
-  outputDir = outputDir || `${context.emitterOutputDir}/CSharp`;
-  const typePath = type.typeName.namespace.split(".");
-
-  // replace typename with file
-  typePath.push(filename);
-  const path = resolvePath(outputDir, filename);
-  await emitFile(context.program, {
-    path,
-    content: python,
-  });
-}
-
-/**
- * Format C# files using dotnet format.
- * Runs formatter from the .NET project root (where .csproj or .sln is located).
- */
-function formatCSharpFiles(outputDir: string, testDir?: string): void {
-  const dirs = [outputDir, ...(testDir ? [testDir] : [])];
-  const formatted = new Set<string>();
-
-  for (const dir of dirs) {
-    const projectRoot = findDotNetProjectRoot(dir);
-    if (!projectRoot) {
-      console.warn(`Warning: Could not find .csproj or .sln file for ${dir}. Skipping formatting.`);
-      continue;
-    }
-
-    // Avoid formatting the same project twice
-    if (formatted.has(projectRoot)) {
-      continue;
-    }
-    formatted.add(projectRoot);
-
-    try {
-      execSync(`dotnet format "${projectRoot}"`, {
-        cwd: dirname(projectRoot),
-        stdio: 'pipe',
-        encoding: 'utf-8'
-      });
-    } catch (error) {
-      console.warn(`Warning: dotnet format failed for ${projectRoot}. You may need to run it manually.`);
-    }
-  }
-}
-
-/**
- * Find the .NET project root by traversing up from the output directory
- * looking for .csproj or .sln files.
- */
-function findDotNetProjectRoot(startDir: string): string | undefined {
-  let currentDir = resolve(startDir);
-  const root = resolve('/');
-
-  // On Windows, also check for drive root (e.g., "C:\")
-  while (currentDir !== root && currentDir !== dirname(currentDir)) {
-    // First check for .csproj (more specific)
-    const files = existsSync(currentDir) ? readdirSync(currentDir) : [];
-    const csprojFile = files.find((f: string) => f.endsWith('.csproj'));
-    if (csprojFile) {
-      return resolve(currentDir, csprojFile);
-    }
-
-    // Then check for .sln
-    const slnFile = files.find((f: string) => f.endsWith('.sln'));
-    if (slnFile) {
-      return resolve(currentDir, slnFile);
-    }
-
-    currentDir = dirname(currentDir);
-  }
-
-  return undefined;
-}
diff --git a/schema/emitter/src/decorators.ts b/schema/emitter/src/decorators.ts
index 5f5ea106..36b423dd 100644
--- a/schema/emitter/src/decorators.ts
+++ b/schema/emitter/src/decorators.ts
@@ -1,15 +1,9 @@
 import { type DecoratorContext, type Model, Program, Type, ModelProperty, ObjectValue, serializeValueAsJson, StringValue } from "@typespec/compiler";
 import { StateKeys } from "./lib.js";
-import { Alternative } from "./ast.js";
-
-export interface SampleOptions {
-  title?: string;
-  description?: string;
-}
+import { Coercion } from "./ir/ast.js";
 
 export const appendStateValue = <T>(context: DecoratorContext, key: symbol, target: Type, value: T | T[]) => {
   const state = context.program.stateMap(key).get(target) || [];
-  // check if value is array
   if (Array.isArray(value)) {
     const newState = [...state, ...value];
     context.program.stateMap(key).set(target, newState);
@@ -32,6 +26,11 @@ export const getStateScalar = <T>(program: Program, key: symbol, target: Type):
   return value ? value : undefined;
 };
 
+export interface SampleOptions {
+  title?: string;
+  description?: string;
+}
+
 export interface SampleEntry {
   sample: object;
   title?: string;
@@ -49,7 +48,7 @@ export function $sample(context: DecoratorContext, target: ModelProperty, sample
     const serialized = serializeValueAsJson(context.program, sampleValue, sampleValue.type);
     if (!serialized) {
       context.program.reportDiagnostic({
-        code: "agentschema-emitter-sample-serialization",
+        code: "prompty-emitter-sample-serialization",
         message: `Failed to serialize sample value.`,
         severity: "error",
         target: sampleValue,
@@ -64,7 +63,7 @@ export function $sample(context: DecoratorContext, target: ModelProperty, sample
 
   if (!s.hasOwnProperty(target.name)) {
     context.program.reportDiagnostic({
-      code: "agentschema-emitter-sample-name-mismatch",
+      code: "prompty-emitter-sample-name-mismatch",
       message: `Sample object must have a property named '${target.name}' to match the target property.`,
       severity: "error",
       target: target,
@@ -79,44 +78,15 @@ export function $sample(context: DecoratorContext, target: ModelProperty, sample
   appendStateValue<SampleEntry>(context, StateKeys.samples, target, entry);
 }
 
-export interface AlternateEntry {
-  scalar: string;
-  alternate: {
-    [key: string]: any;
-  };
-  expansion: {
-    [key: string]: any;
-  };
-  title?: string;
-  description?: string;
-}
-
 export function $abstract(context: DecoratorContext, target: Model) {
   setStateScalar(context, StateKeys.abstracts, target, true);
 }
 
-export function $alternate(context: DecoratorContext, target: ModelProperty, scalar: Type, sample: ObjectValue | object, expansion: ObjectValue | object) {
-  // The alternate decorator provides an alternative sample value with its expansion
-  // Currently a stub - can be extended later if needed
-  if (scalar.kind !== "Scalar") {
-    context.program.reportDiagnostic({
-      code: "agentschema-emitter-alternate-scalar-type",
-      message: `Alternate decorator requires a scalar type.`,
-      severity: "error",
-      target: scalar,
-    });
-    return;
-  }
-  // For now, this is a no-op placeholder
-  // The functionality can be implemented when @alternate is actually used
-}
-
-
-export function $shorthand(context: DecoratorContext, target: Model, scalar: Type, expansion: ObjectValue | object, title?: string, description?: string, example?: string) {
+export function $coerce(context: DecoratorContext, target: Model, scalar: Type, expansion: ObjectValue | object, title?: string, description?: string, example?: string) {
   if (scalar.kind !== "Scalar") {
     context.program.reportDiagnostic({
-      code: "agentschema-emitter-shorthand-scalar-type",
-      message: `Shorthand decorator requires a scalar type for the shorthand representation.`,
+      code: "prompty-emitter-coerce-scalar-type",
+      message: `Coerce decorator requires a scalar type for the scalar representation.`,
       severity: "error",
       target: scalar,
     });
@@ -129,7 +99,7 @@ export function $shorthand(context: DecoratorContext, target: Model, scalar: Typ
     const serialized = serializeValueAsJson(context.program, expansion as ObjectValue, (expansion as ObjectValue).type);
     if (!serialized) {
       context.program.reportDiagnostic({
-        code: "agentschema-emitter-shorthand-serialization",
+        code: "prompty-emitter-coerce-serialization",
         message: `Failed to serialize expansion value.`,
         severity: "error",
         target: target,
@@ -146,12 +116,142 @@ export function $shorthand(context: DecoratorContext, target: Model, scalar: Typ
   const descValue = typeof description === 'object' && description !== null && 'value' in description ? (description as StringValue).value : description as string | undefined;
   const exampleValue = typeof example === 'object' && example !== null && 'value' in example ? (example as StringValue).value : example as string | undefined;
 
-  const entry: Alternative = {
+  const entry: Coercion = {
     scalar: scalar.name,
     expansion: exp,
     example: exampleValue,
     title: titleValue ?? "",
     description: descValue ?? "",
   }
-  appendStateValue<Alternative>(context, StateKeys.shorthands, target, entry);
+  appendStateValue<Coercion>(context, StateKeys.coercions, target, entry);
+}
+
+// ============================================================================
+// Factory and Method decorators
+// ============================================================================
+
+export interface FactoryEntry {
+  /** Factory method name (e.g., "allow", "deny") */
+  name: string;
+  /** Field assignments — { fieldName: value } */
+  sets: Record<string, any>;
+  /** Optional parameters — { paramName: typeString } */
+  params: Record<string, string>;
+}
+
+export interface MethodEntry {
+  /** Method name (e.g., "text") */
+  name: string;
+  /** Return type as a string (e.g., "string") */
+  returns: string;
+  /** Human-readable description of what the method does */
+  description: string;
+  /** Method parameters as an ordered map of name → type string */
+  params: Record<string, string>;
+  /** Whether this method is optional (has a default implementation) */
+  optional: boolean;
+  /** Whether this method is synchronous (not wrapped in async/Promise/Task) */
+  sync: boolean;
+}
+
+function deserializeValue(value: unknown): any {
+  if (value && typeof value === 'object' && 'type' in value && (value as ObjectValue).type) {
+    // ObjectValue from TypeSpec — shouldn't happen with valueof but handle defensively
+    return value;
+  }
+  return value;
+}
+
+export function $factory(context: DecoratorContext, target: Model, name: string, sets: object, params?: object) {
+  // Handle string values from valueof
+  const nameValue = typeof name === 'object' && name !== null && 'value' in name ? (name as StringValue).value : name as string;
+
+  const setsValue = deserializeValue(sets) as Record<string, any>;
+  const paramsValue = params ? deserializeValue(params) as Record<string, string> : {};
+
+  const entry: FactoryEntry = {
+    name: nameValue,
+    sets: setsValue,
+    params: paramsValue,
+  };
+
+  appendStateValue<FactoryEntry>(context, StateKeys.factories, target, entry);
+}
+
+export function $method(context: DecoratorContext, target: Model, name: string, returns: string, description?: string, params?: object, optional?: boolean, sync?: boolean) {
+  const nameValue = typeof name === 'object' && name !== null && 'value' in name ? (name as StringValue).value : name as string;
+  const returnsValue = typeof returns === 'object' && returns !== null && 'value' in returns ? (returns as StringValue).value : returns as string;
+  const descValue = typeof description === 'object' && description !== null && 'value' in description ? (description as StringValue).value : description as string | undefined;
+  const paramsValue = params ? deserializeValue(params) as Record<string, string> : {};
+  const optionalValue = typeof optional === 'object' && optional !== null && 'value' in optional ? (optional as { value: boolean }).value : optional ?? false;
+  const syncValue = typeof sync === 'object' && sync !== null && 'value' in sync ? (sync as { value: boolean }).value : sync ?? false;
+
+  const entry: MethodEntry = {
+    name: nameValue,
+    returns: returnsValue,
+    description: descValue ?? "",
+    params: paramsValue,
+    optional: optionalValue,
+    sync: syncValue,
+  };
+
+  appendStateValue<MethodEntry>(context, StateKeys.methods, target, entry);
+}
+
+// ============================================================================
+// Wire mapping decorators (@knownAs, @defaultFor)
+// ============================================================================
+
+export interface KnownAsEntry {
+  /** Provider identifier (e.g., "openai", "anthropic") */
+  provider: string;
+  /** Wire field name for that provider */
+  name: string;
+}
+
+export function $knownAs(context: DecoratorContext, target: ModelProperty, provider: string, name: string) {
+  const providerValue = typeof provider === 'object' && provider !== null && 'value' in provider ? (provider as StringValue).value : provider as string;
+  const nameValue = typeof name === 'object' && name !== null && 'value' in name ? (name as StringValue).value : name as string;
+
+  const entry: KnownAsEntry = { provider: providerValue, name: nameValue };
+  appendStateValue<KnownAsEntry>(context, StateKeys.knownAs, target, entry);
+}
+
+export interface DefaultForEntry {
+  /** Provider identifier (e.g., "openai", "anthropic") */
+  provider: string;
+  /** Default value for that provider */
+  defaultValue: any;
+}
+
+export function $defaultFor(context: DecoratorContext, target: ModelProperty, provider: string, defaultValue: ObjectValue | object | string | number | boolean) {
+  const providerValue = typeof provider === 'object' && provider !== null && 'value' in provider ? (provider as StringValue).value : provider as string;
+
+  let val: any;
+  if (defaultValue && typeof defaultValue === 'object' && 'type' in defaultValue && (defaultValue as ObjectValue).type) {
+    const serialized = serializeValueAsJson(context.program, defaultValue as ObjectValue, (defaultValue as ObjectValue).type);
+    if (!serialized) {
+      context.program.reportDiagnostic({
+        code: "prompty-emitter-defaultfor-serialization",
+        message: `Failed to serialize default value.`,
+        severity: "error",
+        target: target,
+      });
+      return;
+    }
+    val = serialized;
+  } else {
+    val = defaultValue;
+  }
+
+  const entry: DefaultForEntry = { provider: providerValue, defaultValue: val };
+  appendStateValue<DefaultForEntry>(context, StateKeys.defaultFor, target, entry);
+}
+
+// ============================================================================
+// Protocol decorator
+// ============================================================================
+
+export function $protocol(context: DecoratorContext, target: Model) {
+  setStateScalar(context, StateKeys.protocols, target, true);
 }
diff --git a/schema/emitter/src/emitter.ts b/schema/emitter/src/emitter.ts
index 4acc2a51..82058bd4 100644
--- a/schema/emitter/src/emitter.ts
+++ b/schema/emitter/src/emitter.ts
@@ -1,23 +1,20 @@
-import { fileURLToPath } from 'url';
-import path, { dirname } from 'path';
-import { existsSync, unlinkSync, readdirSync } from 'fs';
+import path from 'path';
+import { existsSync, unlinkSync } from 'fs';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
-import { resolveModel, TypeNode } from "./ast.js";
+import { EmitContext, emitFile, resolvePath, Namespace } from "@typespec/compiler";
+import { resolveModel, TypeNode, enumerateTypes } from "./ir/ast.js";
 import { PromptyEmitterOptions, EmitTarget } from "./lib.js";
-import { generateMarkdown } from "./markdown.js";
-import { generatePython } from "./python.js";
-import { generateCsharp } from "./csharp.js";
-import { generateTypeScript } from "./typescript.js";
-import { generateGo } from "./go.js";
-import { generateRust } from "./rust.js";
+import { generateMarkdown } from "./languages/markdown/driver.js";
+import { generatePython } from "./languages/python/driver.js";
+import { generateCsharp } from "./languages/csharp/driver.js";
+import { generateTypeScript } from "./languages/typescript/driver.js";
+import { generateGo } from "./languages/go/driver.js";
+import { generateRust } from "./languages/rust/driver.js";
 
 // Generator options passed to each generator
 export interface GeneratorOptions {
   omitModels?: string[];
+  additionalModels?: TypeNode[];
 }
 
 /**
@@ -26,6 +23,23 @@ export interface GeneratorOptions {
  */
 export function filterNodes(nodes: TypeNode[], options?: GeneratorOptions): TypeNode[] {
   const omitModels = options?.omitModels || [];
+
+  // Include additional root models and their type trees
+  const additionalModels = options?.additionalModels || [];
+  if (additionalModels.length > 0) {
+    const existingNames = new Set(nodes.map(n => `${n.typeName.namespace}.${n.typeName.name}`));
+    const visited = new Set(existingNames);
+    for (const additionalModel of additionalModels) {
+      for (const subNode of enumerateTypes(additionalModel, new Set())) {
+        const fullName = `${subNode.typeName.namespace}.${subNode.typeName.name}`;
+        if (!visited.has(fullName)) {
+          nodes.push(subNode);
+          visited.add(fullName);
+        }
+      }
+    }
+  }
+
   if (omitModels.length === 0) return nodes;
 
   return nodes.filter(node => {
@@ -38,7 +52,6 @@ export function filterNodes(nodes: TypeNode[], options?: GeneratorOptions): Type
 // Generator function type for code emitters
 type GeneratorFn = (
   context: EmitContext<PromptyEmitterOptions>,
-  templateDir: string,
   model: TypeNode,
   target: EmitTarget,
   options?: GeneratorOptions
@@ -59,7 +72,6 @@ export async function $onEmit(context: EmitContext<PromptyEmitterOptions>) {
 
   const options = {
     emitterOutputDir: context.emitterOutputDir,
-    templateDir: path.resolve(__dirname, 'templates'),
     ...context.options,
   }
 
@@ -82,9 +94,76 @@ export async function $onEmit(context: EmitContext<PromptyEmitterOptions>) {
     }
   }
 
+  // Discover additional models not reachable from the root.
+  // If root-namespace is specified, resolve all models in that namespace
+  // so new types are automatically emitted without manual additional-roots.
+  const rootNamespace = options["root-namespace"] || "Prompty";
+  const additionalModels: TypeNode[] = [];
+  const visited = new Set<string>();
+
+  // Collect names already in the main model tree to avoid duplicates
+  const collectNames = (node: TypeNode) => {
+    visited.add(`${node.typeName.namespace}.${node.typeName.name}`);
+    for (const child of node.childTypes) {
+      collectNames(child);
+    }
+    for (const prop of node.properties) {
+      if (prop.type) {
+        collectNames(prop.type);
+        for (const child of prop.type.childTypes) {
+          collectNames(child);
+        }
+      }
+    }
+  };
+  collectNames(model);
+
+  // Resolve the namespace and iterate all models
+  const nsRef = context.program.resolveTypeReference(rootNamespace);
+  if (nsRef[0] && nsRef[0].kind === "Namespace") {
+    const ns = nsRef[0] as Namespace;
+    for (const [, nsModel] of ns.models) {
+      const fullName = `${rootNamespace}.${nsModel.name}`;
+      if (visited.has(fullName)) continue;
+
+      // Skip uninstantiated template declarations (e.g., Named<T>, Id<T>)
+      if (nsModel.node && 'templateParameters' in nsModel.node &&
+          nsModel.node.templateParameters.length > 0 && !nsModel.templateMapper) {
+        continue;
+      }
+
+      const additionalNode = resolveModel(
+        context.program, nsModel, new Set(),
+        rootNamespace,
+        options["root-alias"] || "Prompty"
+      );
+      additionalModels.push(additionalNode);
+      visited.add(fullName);
+    }
+  }
+
+  // Also process any explicit additional-roots (for types outside the namespace)
+  const additionalRoots = options["additional-roots"] || [];
+  for (const rootName of additionalRoots) {
+    if (visited.has(rootName)) continue;
+    const ref = context.program.resolveTypeReference(rootName);
+    if (!ref[0] || ref[0].kind !== "Model") {
+      console.warn(`Warning: additional-root '${rootName}' not found or is not a model type. Skipping.`);
+      continue;
+    }
+    const additionalNode = resolveModel(
+      context.program, ref[0], new Set(),
+      rootNamespace,
+      options["root-alias"] || "Prompty"
+    );
+    additionalModels.push(additionalNode);
+    visited.add(rootName);
+  }
+
   const targets = options["emit-targets"] || [];
   const generatorOptions: GeneratorOptions = {
     omitModels: options["omit-models"] || [],
+    additionalModels: additionalModels,
   };
 
   // Dispatch to registered generators
@@ -92,7 +171,7 @@ export async function $onEmit(context: EmitContext<PromptyEmitterOptions>) {
     const generatorName = target.type.toLowerCase().trim();
     const generator = generators[generatorName];
     if (generator) {
-      await generator(context, options.templateDir, model, target, generatorOptions);
+      await generator(context, model, target, generatorOptions);
     }
   }
 
diff --git a/schema/emitter/src/generate.ts b/schema/emitter/src/generate.ts
index 750e1308..91b7b648 100644
--- a/schema/emitter/src/generate.ts
+++ b/schema/emitter/src/generate.ts
@@ -1,6 +1,6 @@
 import path from "path";
 import { fileURLToPath } from "url";
-import { execSync } from "child_process";
+import { execSync, execFileSync } from "child_process";
 import { existsSync, mkdirSync, writeFileSync, unlinkSync } from "fs";
 import * as YAML from "yaml";
 
@@ -93,7 +93,7 @@ export interface GenerateResult {
  * 
  * @example
  * ```typescript
- * import { generate } from 'agentschema-emitter/generate';
+ * import { generate } from 'prompty-emitter/generate';
  * 
  * await generate({
  *   output: './generated',
@@ -131,9 +131,9 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
 
   // Create temporary tspconfig.yaml
   const tspConfig = {
-    emit: ["agentschema-emitter"],
+    emit: ["prompty-emitter"],
     options: {
-      "agentschema-emitter": {
+      "prompty-emitter": {
         "emitter-output-dir": outputDir,
         "root-object": rootObject,
         "root-namespace": namespace,
@@ -149,8 +149,8 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
   writeFileSync(tempConfigPath, YAML.stringify(tspConfig));
 
   try {
-    // Run tsp compile
-    execSync(`tsp compile "${modelPath}" --config "${tempConfigPath}"`, {
+    // Run tsp compile — use execFileSync to avoid shell injection
+    execFileSync("tsp", ["compile", modelPath, "--config", tempConfigPath], {
       stdio: "inherit",
       cwd: outputDir,
     });
diff --git a/schema/emitter/src/go.ts b/schema/emitter/src/go.ts
deleted file mode 100644
index 81d4d3e4..00000000
--- a/schema/emitter/src/go.ts
+++ /dev/null
@@ -1,286 +0,0 @@
-import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
-import { execSync } from "child_process";
-import { existsSync } from "fs";
-import { dirname, resolve } from "path";
-import { EmitTarget, PromptyEmitterOptions } from "./lib.js";
-import {
-  BaseTestContext,
-  enumerateTypes,
-  PropertyNode,
-  TypeNode,
-} from "./ast.js";
-import { GeneratorOptions, filterNodes } from "./emitter.js";
-
-import { createTemplateEngine } from "./template-engine.js";
-import { buildBaseTestContext, goTestOptions } from "./test-context.js";
-import { toSnakeCase } from "./utilities.js";
-
-
-/**
- * Type mapping from TypeSpec scalar types to Go types.
- */
-export const goTypeMapper: Record<string, string> = {
-  "string": "string",
-  "number": "float64",
-  "array": "[]",
-  "object": "map[string]interface{}",
-  "boolean": "bool",
-  "int64": "int64",
-  "int32": "int32",
-  "float64": "float64",
-  "float32": "float32",
-  "integer": "int",
-  "float": "float64",
-  "numeric": "float64",
-  "any": "interface{}",
-  "dictionary": "map[string]interface{}",
-};
-
-/**
- * Go context interfaces for template rendering
- */
-interface GoClassContext {
-  node: TypeNode;
-  typeMapper: Record<string, string>;
-  alternates: Array<{ scalar: string; alternate: string }>;
-  polymorphicTypes: any;
-  imports: string[];
-  collectionTypes: Array<{ prop: PropertyNode; type: string[] }>;
-  shorthandProperty: string | null;
-}
-
-interface GoFileContext {
-  containsAbstract: boolean;
-  imports: string[];
-  classes: GoClassContext[];
-  typeMapper: Record<string, string>;
-  packageName: string;
-  polymorphicTypeNames: string[];
-}
-
-interface GoContextContext {
-  header: string;
-  packageName: string;
-}
-
-/**
- * Main entry point for Go code generation.
- */
-export const generateGo = async (
-  context: EmitContext<PromptyEmitterOptions>,
-  templateDir: string,
-  node: TypeNode,
-  emitTarget: EmitTarget,
-  options?: GeneratorOptions
-): Promise<void> => {
-  // Create template engine with Go templates + shared macros
-  const engine = createTemplateEngine(templateDir, 'go');
-
-  const nodes = filterNodes(Array.from(enumerateTypes(node)), options);
-
-  // Determine package name from root node namespace (e.g., "Prompty" -> "prompty")
-  const packageName = node.typeName.namespace.toLowerCase().replace(/\./g, '');
-
-  // Collect all polymorphic type names across all nodes
-  const polymorphicTypeNames = new Set<string>();
-  for (const n of nodes) {
-    const polyTypes = n.retrievePolymorphicTypes();
-    if (polyTypes) {
-      polymorphicTypeNames.add(n.typeName.name);
-    }
-  }
-
-  // Render context file (LoadContext/SaveContext utilities)
-  const contextContext = buildContextContext(packageName);
-  const contextContent = engine.render('context.go.njk', contextContext);
-  await emitGoFile(context, 'context.go', contextContent, emitTarget["output-dir"]);
-
-  // Render each base type and its children as a single file
-  for (const n of nodes) {
-    // Skip child types - they're rendered with their parent
-    if (!n.base) {
-      const fileContext = buildFileContext(n, packageName, polymorphicTypeNames);
-      const fileContent = engine.render('file.go.njk', fileContext);
-      const fileName = toSnakeCase(n.typeName.name) + '.go';
-      await emitGoFile(context, fileName, fileContent, emitTarget["output-dir"]);
-    }
-
-    // Render test file for each type
-    if (emitTarget["test-dir"]) {
-      const testContext = buildTestContext(n, packageName);
-      const testContent = engine.render('test.go.njk', testContext);
-      const testFileName = toSnakeCase(n.typeName.name) + '_test.go';
-      await emitGoFile(context, testFileName, testContent, emitTarget["test-dir"]);
-    }
-  }
-
-  // Format emitted files if format option is enabled (default: true)
-  if (emitTarget.format !== false) {
-    const outputDir = emitTarget["output-dir"]
-      ? resolve(process.cwd(), emitTarget["output-dir"])
-      : context.emitterOutputDir;
-    const testDir = emitTarget["test-dir"]
-      ? resolve(process.cwd(), emitTarget["test-dir"])
-      : undefined;
-
-    formatGoFiles(outputDir, testDir);
-  }
-};
-
-/**
- * Format Go files using gofmt and goimports.
- */
-function formatGoFiles(outputDir: string, testDir?: string): void {
-  const dirs = [outputDir, ...(testDir ? [testDir] : [])];
-
-  for (const dir of dirs) {
-    // Run gofmt
-    try {
-      execSync(`gofmt -w "${dir}"`, {
-        stdio: 'pipe',
-        encoding: 'utf-8'
-      });
-    } catch (error) {
-      console.warn(`Warning: gofmt formatting failed for ${dir}. You may need to install Go.`);
-    }
-
-    // Run goimports if available
-    try {
-      execSync(`goimports -w "${dir}"`, {
-        stdio: 'pipe',
-        encoding: 'utf-8'
-      });
-    } catch (error) {
-      // goimports is optional, don't warn if not available
-    }
-  }
-}
-
-/**
- * Build context for rendering a single Go struct.
- */
-function buildClassContext(node: TypeNode): GoClassContext {
-  return {
-    node,
-    typeMapper: goTypeMapper,
-    alternates: prepareAlternates(node),
-    polymorphicTypes: node.retrievePolymorphicTypes(),
-    imports: getUniqueImportTypes(node),
-    collectionTypes: getCollectionTypes(node),
-    shorthandProperty: getShorthandProperty(node),
-  };
-}
-
-/**
- * Build context for rendering a Go file with a base type and its children.
- */
-function buildFileContext(node: TypeNode, packageName: string, polymorphicTypeNames: Set<string>): GoFileContext {
-  const classes: GoClassContext[] = [
-    buildClassContext(node),
-    ...node.childTypes.map(ct => buildClassContext(ct))
-  ];
-
-  return {
-    containsAbstract: node.isAbstract || node.childTypes.some(c => c.isAbstract),
-    imports: getUniqueImportTypes(node),
-    classes,
-    typeMapper: goTypeMapper,
-    packageName,
-    polymorphicTypeNames: Array.from(polymorphicTypeNames),
-  };
-}
-
-/**
- * Build context for rendering a test file.
- */
-function buildTestContext(node: TypeNode, packageName: string): BaseTestContext {
-  return buildBaseTestContext(node, packageName, goTestOptions);
-}
-
-/**
- * Build context for rendering the context.go file.
- */
-function buildContextContext(packageName: string): GoContextContext {
-  return {
-    header: "Prompty Context",
-    packageName,
-  };
-}
-
-/**
- * Prepare alternate representations for template rendering.
- */
-function prepareAlternates(node: TypeNode): Array<{ scalar: string; alternate: string }> {
-  if (!node.alternates || node.alternates.length === 0) {
-    return [];
-  }
-
-  return node.alternates.map(alt => ({
-    scalar: goTypeMapper[alt.scalar],
-    alternate: JSON.stringify(alt.expansion, null, '')
-      .replaceAll('\n', '')
-      .replaceAll('"{value}"', 'v'),
-  }));
-}
-
-/**
- * Get the shorthand property name from alternates.
- */
-function getShorthandProperty(node: TypeNode): string | null {
-  if (!node.alternates || node.alternates.length === 0) {
-    return null;
-  }
-
-  for (const alt of node.alternates) {
-    for (const [key, value] of Object.entries(alt.expansion)) {
-      if (value === "{value}") {
-        return key;
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Get collection properties with their nested type info.
- */
-function getCollectionTypes(node: TypeNode): Array<{ prop: PropertyNode; type: string[] }> {
-  return node.properties
-    .filter(p => p.isCollection && !p.isScalar && !p.isDict)
-    .map(p => ({
-      prop: p,
-      type: p.type?.properties.filter(t => t.name !== "name").map(t => t.name) || [],
-    }));
-}
-
-/**
- * Get unique import types needed from other modules.
- */
-function getUniqueImportTypes(node: TypeNode): string[] {
-  const imports = [
-    node.properties.filter(p => !p.isScalar && !p.isDict).map(p => p.typeName.name),
-    ...node.childTypes.flatMap(c =>
-      c.properties.filter(p => !p.isScalar && !p.isDict).map(p => p.typeName.name)
-    )
-  ].flat().filter(n => n !== node.typeName.name && node.base?.name !== n);
-
-  return Array.from(new Set(imports)).sort();
-}
-
-/**
- * Write generated Go content to file.
- */
-async function emitGoFile(
-  context: EmitContext<PromptyEmitterOptions>,
-  filename: string,
-  content: string,
-  outputDir?: string
-): Promise<void> {
-  outputDir = outputDir || `${context.emitterOutputDir}/go`;
-  const filePath = resolvePath(outputDir, filename);
-
-  await emitFile(context.program, {
-    path: filePath,
-    content,
-  });
-}
diff --git a/schema/emitter/src/index.ts b/schema/emitter/src/index.ts
index 8f09e599..90473e3c 100644
--- a/schema/emitter/src/index.ts
+++ b/schema/emitter/src/index.ts
@@ -1,4 +1,4 @@
 export { $onEmit, GeneratorOptions, filterNodes } from "./emitter.js";
 export { $lib } from "./lib.js";
-export { $sample, $abstract, $shorthand } from "./decorators.js";
+export { $sample, $abstract, $coerce, $factory, $method, $knownAs, $defaultFor, $protocol } from "./decorators.js";
 export { generate, GenerateOptions, GenerateResult, TargetLanguage, TargetOptions } from "./generate.js";
diff --git a/schema/emitter/src/ast.ts b/schema/emitter/src/ir/ast.ts
similarity index 87%
rename from schema/emitter/src/ast.ts
rename to schema/emitter/src/ir/ast.ts
index 8f19597e..5008f499 100644
--- a/schema/emitter/src/ast.ts
+++ b/schema/emitter/src/ir/ast.ts
@@ -11,8 +11,8 @@ import {
   getNamespaceFullName,
   getDiscriminator,
 } from "@typespec/compiler";
-import { getStateScalar, getStateValue, SampleEntry } from "./decorators.js";
-import { StateKeys } from "./lib.js";
+import { getStateScalar, getStateValue, SampleEntry, FactoryEntry, MethodEntry, KnownAsEntry, DefaultForEntry } from "../decorators.js";
+import { StateKeys } from "../lib.js";
 
 
 export interface TypeName {
@@ -47,7 +47,7 @@ const getModelType = (model: Model, rootNamespace: string, rootAlias: string): T
   };
 };
 
-export interface Alternative {
+export interface Coercion {
   scalar: string;
   expansion: {
     [key: string]: any;
@@ -66,10 +66,13 @@ export class TypeNode {
   public description: string;
   public base: TypeName | null = null;
   public childTypes: TypeNode[] = [];
-  public alternates: Alternative[] = [];
+  public coercions: Coercion[] = [];
   public properties: PropertyNode[] = [];
   public isAbstract: boolean = false;
+  public isProtocol: boolean = false;
   public discriminator: string | undefined = undefined;
+  public factories: FactoryEntry[] = [];
+  public methods: MethodEntry[] = [];
 
   constructor(public model: Model, description: string) {
     this.model = model;
@@ -105,8 +108,11 @@ export class TypeNode {
       description: this.description,
       base: this.base || {},
       isAbstract: this.isAbstract,
+      isProtocol: this.isProtocol,
       discriminator: this.discriminator,
-      alternates: this.alternates,
+      coercions: this.coercions,
+      factories: this.factories,
+      methods: this.methods,
       childTypes: this.childTypes.map(ct => ct.getSanitizedObject()),
       properties: this.properties.map(prop => prop.getSanitizedObject()),
     };
@@ -122,6 +128,8 @@ export class PropertyNode {
   public description: string;
 
   public samples: SampleEntry[] = [];
+  public knownAs: KnownAsEntry[] = [];
+  public defaultFor: DefaultForEntry[] = [];
 
   public isScalar: boolean = false;
   public isOptional: boolean = false;
@@ -147,6 +155,8 @@ export class PropertyNode {
       typeName: this.typeName,
       description: this.description,
       samples: this.samples,
+      knownAs: this.knownAs,
+      defaultFor: this.defaultFor,
 
       isScalar: this.isScalar,
       isOptional: this.isOptional,
@@ -211,19 +221,27 @@ export const resolveModel = (program: Program, model: Model, visited: Set<string
     node.childTypes = resolveModelChildren(program, innerModel, visited, rootNamespace, rootAlias);
     node.description = getDoc(program, innerModel) || "";
     node.isAbstract = getStateScalar<boolean>(program, StateKeys.abstracts, innerModel) || false;
+    node.isProtocol = getStateScalar<boolean>(program, StateKeys.protocols, innerModel) || false;
     const discriminator = getDiscriminator(program, innerModel);
     node.discriminator = discriminator ? discriminator.propertyName : undefined;
-    // shorthand .ctor
-    node.alternates = getStateValue<Alternative>(program, StateKeys.shorthands, innerModel);
+    // coercion .ctor
+    node.coercions = getStateValue<Coercion>(program, StateKeys.coercions, innerModel);
+    // factory and method stubs
+    node.factories = getStateValue<FactoryEntry>(program, StateKeys.factories, innerModel);
+    node.methods = getStateValue<MethodEntry>(program, StateKeys.methods, innerModel);
     visited.add(innerModel.name);
   } else {
     node.typeName = getModelType(model, rootNamespace, rootAlias);
     node.childTypes = resolveModelChildren(program, model, visited, rootNamespace, rootAlias);
     node.isAbstract = getStateScalar<boolean>(program, StateKeys.abstracts, model) || false;
+    node.isProtocol = getStateScalar<boolean>(program, StateKeys.protocols, model) || false;
     const discriminator = getDiscriminator(program, model);
     node.discriminator = discriminator ? discriminator.propertyName : undefined;
-    // shorthand .ctor
-    node.alternates = getStateValue<Alternative>(program, StateKeys.shorthands, model);
+    // coercion .ctor
+    node.coercions = getStateValue<Coercion>(program, StateKeys.coercions, model);
+    // factory and method stubs
+    node.factories = getStateValue<FactoryEntry>(program, StateKeys.factories, model);
+    node.methods = getStateValue<MethodEntry>(program, StateKeys.methods, model);
     visited.add(model.name);
   }
 
@@ -240,6 +258,9 @@ export const resolveModel = (program: Program, model: Model, visited: Set<string
       const prop = resolveProperty(program, value, visited, rootNamespace, rootAlias);
       // samples
       prop.samples = getStateValue<SampleEntry>(program, StateKeys.samples, value);
+      // wire mappings
+      prop.knownAs = getStateValue<KnownAsEntry>(program, StateKeys.knownAs, value);
+      prop.defaultFor = getStateValue<DefaultForEntry>(program, StateKeys.defaultFor, value);
 
       properties.push(prop);
     }
@@ -287,7 +308,7 @@ export const resolveProperty = (program: Program, property: ModelProperty, visit
 
     default:
       program.reportDiagnostic({
-        code: "agentschema-emitter-unsupported-property-type",
+        code: "prompty-emitter-unsupported-property-type",
         message: `Unsupported property type: ${property.type.kind}`,
         severity: "error",
         target: property
@@ -428,7 +449,7 @@ export const resolveModelProperty = (program: Program, property: ModelProperty,
         };
       } else {
         program.reportDiagnostic({
-          code: "agentschema-emitter-unsupported-array-type",
+          code: "prompty-emitter-unsupported-array-type",
           message: `Unsupported array type: ${getTypeName(model)}`,
           severity: "error",
           target: property
@@ -499,7 +520,7 @@ export const resolveUnionProperty = (program: Program, property: ModelProperty,
         }
       } else {
         program.reportDiagnostic({
-          code: "agentschema-emitter-unsupported-union-types",
+          code: "prompty-emitter-unsupported-union-types",
           message: `Unsupported union types for Record/Array: ${recordType?.name} / ${arrayType?.name} - they should match.`,
           severity: "error",
           target: property
@@ -518,7 +539,7 @@ export const resolveUnionProperty = (program: Program, property: ModelProperty,
         }
       } else {
         program.reportDiagnostic({
-          code: "agentschema-emitter-named-model-union-types",
+          code: "prompty-emitter-named-model-union-types",
           message: `Named model union types must match! (${models.map(m => m.name).join(", ")})`,
           severity: "error",
           target: property
@@ -527,7 +548,7 @@ export const resolveUnionProperty = (program: Program, property: ModelProperty,
       }
     } else {
       program.reportDiagnostic({
-        code: "agentschema-emitter-unsupported-union-types",
+        code: "prompty-emitter-unsupported-union-types",
         message: `Unsupported union type: ${union.kind}`,
         severity: "error",
         target: property
@@ -550,7 +571,7 @@ export const resolveUnionProperty = (program: Program, property: ModelProperty,
       const s = 1;
     } else {
       program.reportDiagnostic({
-        code: "agentschema-emitter-unsupported-union-types",
+        code: "prompty-emitter-unsupported-union-types",
         message: `Unable to resolve ${union.name} - too many variants: (${models.map(m => m.name).join(", ")})`,
         severity: "error",
         target: property
@@ -599,16 +620,24 @@ export interface PythonClassContext {
   node: TypeNode;
   /** Type mapping from TypeSpec types to Python types */
   typeMapper: Record<string, string>;
-  /** Processed alternate representations for shorthand constructors */
-  alternates: Array<{ scalar: string; alternate: string }>;
+  /** Processed coercion representations for scalar-to-object constructors */
+  coercions: Array<{ scalar: string; alternate: string }>;
   /** Polymorphic type information if this is a discriminated type */
   polymorphicTypes: ReturnType<TypeNode['retrievePolymorphicTypes']> | undefined;
   /** Import types needed from other modules */
   imports: string[];
   /** Collection properties with their nested type info for load_* methods */
   collectionTypes: Array<{ prop: PropertyNode; type: string[] }>;
-  /** The property name that can be used as a shorthand scalar representation */
-  shorthandProperty: string | null;
+  /** The property name that receives the scalar value in a coercion expansion */
+  coercionProperty: string | null;
+  /** Maps factory.name → safe Python method name (prefixed with create_ on field collision) */
+  factoryNameMap: Record<string, string>;
+  /** Pre-rendered factory method bodies via expression IR */
+  renderedFactories: Array<{ name: string; safeName: string; params: Record<string, string>; body: string }>;
+  /** Pre-rendered coercion expressions via expression IR */
+  renderedCoercions: Array<{ scalar: string; expression: string }>;
+  /** Type names referenced in factory expressions (for file-level import resolution) */
+  factoryTypeRefs: string[];
 }
 
 /**
@@ -619,8 +648,8 @@ export interface PythonFileContext {
   containsAbstract: boolean;
   /** Python typing imports needed (e.g., "Any", "Callable", "Optional") */
   typings: string[];
-  /** Import types needed from other modules */
-  imports: string[];
+  /** Grouped imports: each entry maps a module name to the types imported from it */
+  imports: Array<{ module: string; names: string[] }>;
   /** Array of class contexts to render */
   classes: PythonClassContext[];
   /** Type mapping from TypeSpec types to Python types */
@@ -649,8 +678,8 @@ export interface PythonTestContext {
     yaml: string[];
     validation: Array<{ key: string; value: any; delimeter: string }>;
   }>;
-  /** Alternate representation tests */
-  alternates: Array<{
+  /** Coercion representation tests */
+  coercions: Array<{
     title: string;
     scalar: string;
     value: string;
@@ -710,9 +739,9 @@ export interface TestExample {
 }
 
 /**
- * A shorthand/alternate representation test case.
+ * A coercion (scalar-to-object) representation test case.
  */
-export interface AlternateTest {
+export interface CoercionTest {
   /** Human-readable test name/title */
   title: string;
   /** Scalar type name in target language */
@@ -736,6 +765,8 @@ export interface BaseTestContext {
   package?: string;
   /** Test examples from @sample decorators */
   examples: TestExample[];
-  /** Shorthand alternate representation tests */
-  alternates: AlternateTest[];
+  /** Coercion (scalar-to-object) representation tests */
+  coercions: CoercionTest[];
+  /** Factory methods declared via @factory (for auto-generated factory tests) */
+  factories: FactoryEntry[];
 }
diff --git a/schema/emitter/src/ir/declarations.ts b/schema/emitter/src/ir/declarations.ts
new file mode 100644
index 00000000..80172696
--- /dev/null
+++ b/schema/emitter/src/ir/declarations.ts
@@ -0,0 +1,378 @@
+/**
+ * Declaration IR — Type-level code generation for the emitter.
+ *
+ * This module defines the "declaration" IR that replaces Nunjucks templates.
+ * Where the Expression IR (expansion.ts) handles factory/coercion bodies,
+ * the Declaration IR handles entire type definitions: structs, fields,
+ * load/save methods, polymorphic dispatch, collection helpers, and factories.
+ *
+ * Architecture:
+ *   TypeNode graph → lowerFile() → FileDecl → emitPythonFile() → .py code
+ *                                            → emitRustFile()   → .rs code
+ *                                            → emitTypeScriptFile() → .ts code
+ *                                            → emitCSharpFile() → .cs code
+ *                                            → emitGoFile()     → .go code
+ *
+ * The lowering pass (lower.ts) converts the TypeNode graph into FileDecl trees.
+ * Per-language emitter functions walk the FileDecl tree to produce code.
+ *
+ * Key design principle: PropertyCategory is the fundamental 5-way classification
+ * that drives ALL per-property code generation across all languages.
+ */
+
+import { TypeName } from "./ast.js";
+import { Expr } from "./expansion.js";
+
+// ============================================================================
+// PropertyCategory — the fundamental classification
+// ============================================================================
+
+/**
+ * Every property in the type system falls into exactly one of these categories.
+ * This classification determines:
+ *   - Type annotation in each language
+ *   - Default value
+ *   - Load (deserialization) pattern
+ *   - Save (serialization) pattern
+ *   - Whether a collection helper is generated
+ *
+ * Templates previously computed this via chains of `if isScalar && isCollection && !isDict`.
+ * Now it's classified once in the lowering pass.
+ */
+export type PropertyCategory =
+  | { kind: "scalar"; scalarType: string }
+  | { kind: "complex"; typeName: string }
+  | { kind: "collection_scalar"; scalarType: string }
+  | { kind: "collection_complex"; typeName: string }
+  | { kind: "dict" };
+
+// ============================================================================
+// FileDecl — a complete generated file
+// ============================================================================
+
+/**
+ * Represents an entire generated source file.
+ * Contains one or more types (parent + children for polymorphic types),
+ * resolved imports, and file-level metadata.
+ */
+export interface FileDecl {
+  /** Primary type name (used for file naming) */
+  typeName: TypeName;
+  /** All types defined in this file (parent first, then children) */
+  types: TypeDecl[];
+  /** Resolved imports — each entry maps a module to the symbols imported from it */
+  imports: ImportRef[];
+  /** Whether any type in the file is abstract */
+  containsAbstract: boolean;
+}
+
+/**
+ * A single import statement grouping: one module, multiple symbols.
+ */
+export interface ImportRef {
+  /** Module/file to import from (e.g., "ContentPart" in Python, "content-part" in TS) */
+  module: string;
+  /** Symbols imported from that module (e.g., ["ContentPart", "TextPart"]) */
+  names: string[];
+}
+
+// ============================================================================
+// TypeDecl — a single type definition
+// ============================================================================
+
+/**
+ * Represents a complete type definition (class/struct/dataclass).
+ * Contains everything needed to generate the type and all its methods.
+ */
+export interface TypeDecl {
+  /** Type name */
+  typeName: TypeName;
+  /** Parent type name (for inheritance) */
+  base: TypeName | null;
+  /** Whether this type is abstract (Python: ABC, C#: abstract, TS: abstract) */
+  isAbstract: boolean;
+  /** Whether this type is a protocol interface (Python: Protocol, TS: interface, Rust: trait, C#: interface, Go: interface) */
+  isProtocol: boolean;
+  /** Human-readable description for docstrings/comments */
+  description: string;
+  /** All fields defined on this type */
+  fields: FieldDecl[];
+  /** The property name that receives scalar coercion value, if any */
+  coercionProperty: string | null;
+  /** Load method specification */
+  load: LoadDecl;
+  /** Save method specification */
+  save: SaveDecl;
+  /** Factory methods (reuse Expr IR for bodies) */
+  factories: FactoryDecl[];
+  /** Collection helper methods (load_items/save_items for complex collections) */
+  collectionHelpers: CollectionHelperDecl[];
+  /** Polymorphic dispatch specification (if this type has a discriminator) */
+  polymorphicDispatch: PolymorphicDispatchDecl | null;
+  /** Method stubs to be implemented in extension modules */
+  methods: MethodStubDecl[];
+  /** Wire conversion specification (generated when any field has knownAs mappings) */
+  wire: WireDecl | null;
+}
+
+// ============================================================================
+// FieldDecl — a single field/property
+// ============================================================================
+
+/**
+ * Represents a single field on a type.
+ * The category determines ALL code generation patterns for this field.
+ */
+export interface FieldDecl {
+  /** Original property name from TypeSpec (camelCase) */
+  name: string;
+  /** Type name for annotations */
+  typeName: TypeName;
+  /** The fundamental classification that drives code generation */
+  category: PropertyCategory;
+  /** Whether this field is optional (None/null/nil default) */
+  isOptional: boolean;
+  /** Default value for the field (primitives only) */
+  defaultValue: string | number | boolean | null;
+  /** Allowed string values (for enum-like constraints) */
+  allowedValues: string[];
+  /** Human-readable description for docstrings */
+  description: string;
+  /** Wire name mappings per provider (e.g., { openai: "max_completion_tokens" }) */
+  knownAs: Record<string, string>;
+}
+
+// ============================================================================
+// LoadDecl — load/deserialization method
+// ============================================================================
+
+/**
+ * Specification for the load()/load_from_value() static method.
+ * The emitter generates per-property deserialization based on field categories.
+ */
+export interface LoadDecl {
+  /** Coercion checks applied before dict validation (isinstance checks) */
+  coercions: CoercionDecl[];
+  /** Per-property load assignments, ordered by field order */
+  assignments: LoadAssignment[];
+  /** Whether this type dispatches to polymorphic subtypes */
+  hasPolymorphicDispatch: boolean;
+  /** Whether LoadContext hooks are applied (process_input, process_output) */
+  hasContextHooks: boolean;
+}
+
+/**
+ * A coercion check: if the input matches a scalar type, transform it.
+ *
+ * Emitters use `assignments` for direct property setting (no intermediate dict).
+ */
+export interface CoercionDecl {
+  /** Scalar type name from TypeSpec (e.g., "string", "boolean", "int64") */
+  scalarType: string;
+  /** Structured assignments — each property to set on the new instance */
+  assignments: CoercionAssignment[];
+  /**
+   * True when the coercion involves a dynamic discriminator value on a
+   * type with child variants.  The emitter must call the dispatch method
+   * (e.g. `load_kind()`) instead of constructing the instance directly.
+   */
+  needsDispatch: boolean;
+}
+
+/**
+ * A single field assignment within a coercion.
+ */
+export interface CoercionAssignment {
+  /** Property name (camelCase, as declared in TypeSpec) */
+  fieldName: string;
+  /** True when the value comes from the scalar input data */
+  isInput: boolean;
+  /** Literal string value when `isInput` is false */
+  literalValue?: string;
+}
+
+/**
+ * A single property load assignment.
+ * The category determines the deserialization pattern used by each language emitter.
+ */
+export interface LoadAssignment {
+  /** Original property name (dict key, camelCase) */
+  sourceName: string;
+  /** Field to assign to (same as sourceName — emitters apply their own casing) */
+  fieldName: string;
+  /** Category determines the load pattern */
+  category: PropertyCategory;
+  /** Whether the field is optional */
+  isOptional: boolean;
+  /** Parent type name (needed for calling collection helpers like Parent.load_items) */
+  parentTypeName: string;
+}
+
+// ============================================================================
+// SaveDecl — save/serialization method
+// ============================================================================
+
+/**
+ * Specification for the save() instance method.
+ */
+export interface SaveDecl {
+  /** Per-property save assignments */
+  assignments: SaveAssignment[];
+  /** Whether to call super().save() first (has a base class) */
+  hasBase: boolean;
+  /** Whether SaveContext hooks are applied (process_object, process_dict) */
+  hasContextHooks: boolean;
+}
+
+/**
+ * A single property save assignment.
+ */
+export interface SaveAssignment {
+  /** Property name (dict key to write to, camelCase) */
+  targetName: string;
+  /** Field name to read from (same as targetName — emitters apply their own casing) */
+  fieldName: string;
+  /** Category determines the serialization pattern */
+  category: PropertyCategory;
+  /** Whether the field is optional (skip if null/None/nil) */
+  isOptional: boolean;
+  /** Parent type name (for collection save helpers) */
+  parentTypeName: string;
+}
+
+// ============================================================================
+// PolymorphicDispatchDecl — discriminator-based type dispatch
+// ============================================================================
+
+/**
+ * Specification for discriminator-based polymorphic dispatch.
+ * Generated as load_kind() in Python, loadKind() in TS, switch in C#, etc.
+ */
+export interface PolymorphicDispatchDecl {
+  /** Discriminator field name (e.g., "kind") */
+  discriminatorField: string;
+  /** Concrete variant types with their discriminator values */
+  variants: PolymorphicVariant[];
+  /** Default/fallback type (wildcard or self-reference for non-abstract bases) */
+  defaultVariant: PolymorphicDefault | null;
+  /** Whether the base type is abstract (affects error handling on unknown values) */
+  isAbstract: boolean;
+}
+
+/**
+ * A concrete polymorphic variant (a child type with a known discriminator value).
+ */
+export interface PolymorphicVariant {
+  /** Discriminator value that selects this variant (e.g., "text", "function") */
+  value: string;
+  /** Type to construct when this variant is matched */
+  typeName: TypeName;
+}
+
+/**
+ * Default/fallback for polymorphic dispatch.
+ */
+export interface PolymorphicDefault {
+  /** The fallback type */
+  typeName: TypeName;
+  /** Whether this is a self-reference (base type falling back to itself — avoid infinite recursion) */
+  isSelfReference: boolean;
+}
+
+// ============================================================================
+// CollectionHelperDecl — load_items/save_items for complex collections
+// ============================================================================
+
+/**
+ * Specification for collection helper methods.
+ * Generated for properties that are collections of complex types
+ * (e.g., list[Tool], Vec<Property>).
+ *
+ * These handle the dict↔array format conversion:
+ *   - Array format: [{ name: "a", kind: "b" }, ...]
+ *   - Dict/object format: { "a": { kind: "b" }, ... }
+ */
+export interface CollectionHelperDecl {
+  /** Property name (used for method naming: load_<name>, save_<name>) */
+  propertyName: string;
+  /** Element type name (the type being loaded/saved) */
+  elementTypeName: TypeName;
+  /** Field names on the element type (excluding "name" — used for shorthand detection) */
+  innerFields: string[];
+  /** Whether the element type has a "name" property (enables dict format) */
+  hasNameProperty: boolean;
+}
+
+// ============================================================================
+// FactoryDecl — factory method (reuses Expr IR)
+// ============================================================================
+
+/**
+ * A factory method declaration.
+ * The body is a pre-resolved Expr from the expression IR — emitters
+ * visit it with their ExprVisitor to produce language-specific code.
+ */
+export interface FactoryDecl {
+  /** Original factory name from @factory decorator */
+  name: string;
+  /** Parameter name → type string mapping */
+  params: Record<string, string>;
+  /** Pre-resolved expression tree for the factory body */
+  body: Expr;
+}
+
+// ============================================================================
+// MethodStubDecl — helper method stubs
+// ============================================================================
+
+/**
+ * A method stub to be implemented in an extension module.
+ * Generated as comments/trait stubs pointing users to implement these.
+ * For protocol types, generates full interface method signatures.
+ */
+export interface MethodStubDecl {
+  /** Method name */
+  name: string;
+  /** Return type as a string */
+  returns: string;
+  /** Human-readable description */
+  description: string;
+  /** Method parameters as ordered map of name → type string */
+  params: Record<string, string>;
+  /** Whether this method is optional (has a default implementation) */
+  optional: boolean;
+  /** Whether this method is synchronous (not wrapped in async/Promise/Task) */
+  sync: boolean;
+}
+
+// ============================================================================
+// WireDecl — provider-specific wire format conversion
+// ============================================================================
+
+/**
+ * Specification for the toWire(provider) method.
+ * Generated when at least one field on a type has knownAs mappings.
+ * Maps camelCase field names to provider-specific wire names.
+ */
+export interface WireDecl {
+  /** All known provider identifiers (e.g., ["openai", "anthropic"]) */
+  providers: string[];
+  /** Per-field wire name mappings */
+  mappings: WireFieldMapping[];
+}
+
+/**
+ * A single field's wire name mappings across providers.
+ */
+export interface WireFieldMapping {
+  /** Original field name (camelCase) */
+  fieldName: string;
+  /** Category of the field (for serialization) */
+  category: PropertyCategory;
+  /** Whether the field is optional */
+  isOptional: boolean;
+  /** Parent type name (for collection helpers) */
+  parentTypeName: string;
+  /** Provider → wire field name map */
+  wireNames: Record<string, string>;
+}
diff --git a/schema/emitter/src/ir/expansion.ts b/schema/emitter/src/ir/expansion.ts
new file mode 100644
index 00000000..11adc77c
--- /dev/null
+++ b/schema/emitter/src/ir/expansion.ts
@@ -0,0 +1,604 @@
+/**
+ * Expression IR — Type-directed lowering for the emitter.
+ *
+ * This module implements the "lowering" pass of the transpiler:
+ * given an untyped data literal (from @factory sets or @coerce expansion)
+ * and a target type (TypeNode/PropertyNode), produce a typed Expr tree.
+ *
+ * The Expr tree is language-agnostic. Per-language visitors in render-expr.ts
+ * walk it to produce target language code.
+ *
+ * Architecture (following TypeScript/Roslyn/Babel pattern):
+ *   Data literal + Type graph → resolve() → Expr tree → visit() → code string
+ */
+
+import { TypeNode, PropertyNode, TypeName } from "./ast.js";
+
+// ============================================================================
+// Expression IR — Algebraic Data Type (sum type)
+// ============================================================================
+
+/** A literal string value. */
+export interface StringLiteral {
+  kind: "string";
+  value: string;
+}
+
+/** A literal number value. */
+export interface NumberLiteral {
+  kind: "number";
+  value: number;
+}
+
+/** A literal boolean value. */
+export interface BooleanLiteral {
+  kind: "boolean";
+  value: boolean;
+}
+
+/** A null/None/nil value. */
+export interface NullLiteral {
+  kind: "null";
+}
+
+/** Reference to a factory/coercion parameter (substituted at runtime). */
+export interface ParamRef {
+  kind: "param";
+  name: string;
+  paramType: string;
+}
+
+/** Direct construction of a non-polymorphic type. */
+export interface Construct {
+  kind: "construct";
+  typeName: TypeName;
+  fields: FieldAssignment[];
+}
+
+/**
+ * Construction of a discriminated union variant.
+ * The base type has a discriminator field; we're constructing a specific child.
+ */
+export interface VariantConstruct {
+  kind: "variant";
+  baseTypeName: TypeName;
+  discriminator: string;
+  discriminatorValue: string;
+  variantTypeName: TypeName;
+  fields: FieldAssignment[];
+}
+
+/** An array/list/vector literal. */
+export interface ArrayLiteral {
+  kind: "array";
+  elementTypeName: TypeName;
+  items: Expr[];
+}
+
+/** A dictionary/map literal. */
+export interface DictLiteral {
+  kind: "dict";
+  entries: { key: string; value: Expr }[];
+}
+
+/**
+ * A field read from a source object. Used in wire format mapping
+ * to read fields from core types (e.g., `opts.maxOutputTokens`).
+ */
+export interface FieldRead {
+  kind: "field_read";
+  /** Source object/variable name (e.g., "opts") */
+  objectName: string;
+  /** Field name on the source object (e.g., "maxOutputTokens") */
+  fieldName: string;
+  /** Type of the field (e.g., "int32", "string") */
+  fieldType: string;
+  /** Whether the field is optional on the source object */
+  isOptional: boolean;
+}
+
+/** A field assignment within a Construct or VariantConstruct. */
+export interface FieldAssignment {
+  /** Original property name from TypeSpec (camelCase). */
+  propertyName: string;
+  value: Expr;
+  /** Whether the target property is optional (emitters may need wrapping, e.g., Some(), null check) */
+  isOptional: boolean;
+}
+
+/** The Expression IR — a tagged union with exhaustive pattern matching. */
+export type Expr =
+  | StringLiteral
+  | NumberLiteral
+  | BooleanLiteral
+  | NullLiteral
+  | ParamRef
+  | Construct
+  | VariantConstruct
+  | ArrayLiteral
+  | DictLiteral
+  | FieldRead;
+
+// ============================================================================
+// Type reference collection — for factory import resolution
+// ============================================================================
+
+/**
+ * Recursively collect all TypeName references from an Expr tree.
+ * Used by emitters to determine which additional types need importing
+ * when factory/coercion expressions reference types from other modules.
+ */
+export function collectExprTypeRefs(expr: Expr): TypeName[] {
+  const refs: TypeName[] = [];
+  function walk(e: Expr) {
+    switch (e.kind) {
+      case "construct":
+        refs.push(e.typeName);
+        e.fields.forEach(f => walk(f.value));
+        break;
+      case "variant":
+        refs.push(e.baseTypeName);
+        refs.push(e.variantTypeName);
+        e.fields.forEach(f => walk(f.value));
+        break;
+      case "array":
+        refs.push(e.elementTypeName);
+        e.items.forEach(walk);
+        break;
+      case "dict":
+        e.entries.forEach(ent => walk(ent.value));
+        break;
+      case "string":
+      case "number":
+      case "boolean":
+      case "null":
+      case "param":
+      case "field_read":
+        break;
+    }
+  }
+  walk(expr);
+  return refs;
+}
+
+// ============================================================================
+// Type Registry — flat lookup for type-directed resolution
+// ============================================================================
+
+/**
+ * Registry of TypeNodes by name, enabling the resolver to look up types
+ * when processing nested objects and discriminated unions.
+ *
+ * Built from the emitter's type graph (TypeNode tree + enumerateTypes).
+ */
+export class TypeRegistry {
+  private types = new Map<string, TypeNode>();
+
+  /** Register a type by its simple name. */
+  register(node: TypeNode): void {
+    this.types.set(node.typeName.name, node);
+  }
+
+  /** Look up a type by simple name. Returns undefined if not found. */
+  get(name: string): TypeNode | undefined {
+    return this.types.get(name);
+  }
+
+  /** Build a registry from a root TypeNode by walking all reachable types. */
+  static fromTypeGraph(roots: TypeNode[]): TypeRegistry {
+    const registry = new TypeRegistry();
+    const visited = new Set<string>();
+
+    function walk(node: TypeNode): void {
+      const key = `${node.typeName.namespace}.${node.typeName.name}`;
+      if (visited.has(key)) return;
+      visited.add(key);
+      registry.register(node);
+      for (const child of node.childTypes) {
+        walk(child);
+      }
+      for (const prop of node.properties) {
+        if (prop.type) {
+          walk(prop.type);
+        }
+      }
+    }
+
+    for (const root of roots) {
+      walk(root);
+    }
+    return registry;
+  }
+}
+
+// ============================================================================
+// Resolver — type-directed lowering (the "frontend")
+// ============================================================================
+
+/** Regex matching a `{paramName}` placeholder (must be the entire string). */
+const PARAM_PLACEHOLDER = /^\{(\w+)\}$/;
+
+/**
+ * Resolve a @factory decorator into a typed Expr tree.
+ *
+ * @param sets - Field assignments from the decorator (e.g., { allowed: true })
+ * @param params - Parameter declarations (e.g., { reason: "string" })
+ * @param targetType - The TypeNode this factory constructs
+ * @param registry - Type registry for resolving nested types
+ * @returns A Construct expression representing the factory body
+ */
+export function resolveFactoryExpr(
+  sets: Record<string, unknown>,
+  params: Record<string, string>,
+  targetType: TypeNode,
+  registry: TypeRegistry,
+): Construct {
+  const fields: FieldAssignment[] = [];
+
+  // 1. Resolve each explicitly-set field
+  for (const [fieldName, value] of Object.entries(sets)) {
+    const prop = targetType.properties.find(p => p.name === fieldName);
+    if (!prop) {
+      throw new Error(
+        `Property '${fieldName}' not found on type '${targetType.typeName.name}'. ` +
+        `Available: [${targetType.properties.map(p => p.name).join(", ")}]`
+      );
+    }
+    fields.push({
+      propertyName: fieldName,
+      value: resolveValue(value, prop, params, registry),
+      isOptional: prop.isOptional,
+    });
+  }
+
+  // 2. Add flat params — params that match a top-level property not already in sets
+  for (const [paramName, paramType] of Object.entries(params)) {
+    if (paramName in sets) continue; // already handled as a nested placeholder
+    // Check if this param was consumed as a placeholder inside sets
+    if (isParamConsumedInSets(paramName, sets)) continue;
+    const prop = targetType.properties.find(p => p.name === paramName);
+    if (!prop) {
+      throw new Error(
+        `Parameter '${paramName}' does not match any property on type '${targetType.typeName.name}'. ` +
+        `Available: [${targetType.properties.map(p => p.name).join(", ")}]`
+      );
+    }
+    fields.push({
+      propertyName: paramName,
+      value: { kind: "param", name: paramName, paramType },
+      isOptional: prop.isOptional,
+    });
+  }
+
+  return {
+    kind: "construct",
+    typeName: targetType.typeName,
+    fields,
+  };
+}
+
+/**
+ * Resolve a @coerce decorator into a typed Expr tree.
+ *
+ * A coercion is essentially a factory with a single implicit parameter named "value".
+ * The expansion dict maps property names to values, where "{value}" is the parameter ref.
+ *
+ * @param expansion - The expansion dict (e.g., { id: "{value}" })
+ * @param scalarType - The scalar type string (e.g., "string")
+ * @param targetType - The TypeNode this coercion constructs
+ * @param registry - Type registry for resolving nested types
+ * @returns A Construct expression representing the coercion expansion
+ */
+export function resolveCoerceExpr(
+  expansion: Record<string, unknown>,
+  scalarType: string,
+  targetType: TypeNode,
+  registry: TypeRegistry,
+  paramName: string = "value",
+): Construct {
+  // The expansion uses {value} as the fixed placeholder. Resolve with "value" as param,
+  // then rename the ParamRef to the caller's desired paramName.
+  const expr = resolveFactoryExpr(expansion, { value: scalarType }, targetType, registry);
+  if (paramName !== "value") {
+    renameParam(expr, "value", paramName);
+  }
+  return expr;
+}
+
+/** Recursively rename a ParamRef in an Expr tree. */
+function renameParam(expr: Expr, from: string, to: string): void {
+  switch (expr.kind) {
+    case "param":
+      if (expr.name === from) expr.name = to;
+      break;
+    case "construct":
+      for (const f of expr.fields) renameParam(f.value, from, to);
+      break;
+    case "variant":
+      for (const f of expr.fields) renameParam(f.value, from, to);
+      break;
+    case "array":
+      for (const item of expr.items) renameParam(item, from, to);
+      break;
+    case "dict":
+      for (const entry of expr.entries) renameParam(entry.value, from, to);
+      break;
+    // Literals and field reads don't contain params
+    case "string":
+    case "number":
+    case "boolean":
+    case "null":
+    case "field_read":
+      break;
+    default: {
+      const _exhaustive: never = expr;
+      throw new Error(`Unknown expr kind: ${(_exhaustive as Expr).kind}`);
+    }
+  }
+}
+
+// ============================================================================
+// Internal resolution — structural recursion, type-directed
+// ============================================================================
+
+/**
+ * Resolve a single value against a property's type.
+ * This is the core recursive function — it dispatches on the value's shape
+ * and the target property's type information.
+ */
+function resolveValue(
+  value: unknown,
+  prop: PropertyNode,
+  params: Record<string, string>,
+  registry: TypeRegistry,
+): Expr {
+  // String value — could be a literal, a param ref, or a nested field
+  if (typeof value === "string") {
+    return resolveStringValue(value, prop, params);
+  }
+
+  // Boolean literal
+  if (typeof value === "boolean") {
+    return { kind: "boolean", value };
+  }
+
+  // Number literal
+  if (typeof value === "number") {
+    return { kind: "number", value };
+  }
+
+  // Null
+  if (value === null || value === undefined) {
+    return { kind: "null" };
+  }
+
+  // Array — resolve each element against the collection's element type
+  if (Array.isArray(value)) {
+    return resolveArrayValue(value, prop, params, registry);
+  }
+
+  // Object — resolve as a typed construction (possibly polymorphic)
+  if (typeof value === "object") {
+    return resolveObjectValue(value as Record<string, unknown>, prop, params, registry);
+  }
+
+  throw new Error(`Cannot resolve value of type '${typeof value}' for property '${prop.name}'`);
+}
+
+/**
+ * Resolve a string value — either a param placeholder or a string literal.
+ */
+function resolveStringValue(
+  value: string,
+  _prop: PropertyNode,
+  params: Record<string, string>,
+): Expr {
+  const match = PARAM_PLACEHOLDER.exec(value);
+  if (match) {
+    const paramName = match[1];
+    if (paramName in params) {
+      return { kind: "param", name: paramName, paramType: params[paramName] };
+    }
+    throw new Error(
+      `Placeholder '{${paramName}}' does not match any declared parameter. ` +
+      `Available: [${Object.keys(params).join(", ")}]`
+    );
+  }
+  return { kind: "string", value };
+}
+
+/**
+ * Resolve an array value against a collection property.
+ */
+function resolveArrayValue(
+  items: unknown[],
+  prop: PropertyNode,
+  params: Record<string, string>,
+  registry: TypeRegistry,
+): ArrayLiteral {
+  if (!prop.isCollection && !prop.type) {
+    // If property isn't marked as collection, use its type name for the array
+  }
+
+  // Get the element type — from prop.type (which is the element TypeNode for collections)
+  const elementType = prop.type;
+  const elementTypeName = prop.typeName;
+
+  const resolvedItems = items.map((item, index) => {
+    if (elementType && typeof item === "object" && item !== null && !Array.isArray(item)) {
+      return resolveObjectAgainstType(item as Record<string, unknown>, elementType, params, registry);
+    }
+    // For scalar array elements, create a synthetic property to resolve against
+    if (typeof item === "string") {
+      return resolveStringValue(item, prop, params);
+    }
+    if (typeof item === "boolean") {
+      return { kind: "boolean" as const, value: item };
+    }
+    if (typeof item === "number") {
+      return { kind: "number" as const, value: item };
+    }
+    throw new Error(`Cannot resolve array element at index ${index} for property '${prop.name}'`);
+  });
+
+  return {
+    kind: "array",
+    elementTypeName,
+    items: resolvedItems,
+  };
+}
+
+/**
+ * Resolve an object value against a property's type.
+ * Delegates to resolveObjectAgainstType after finding the target type.
+ */
+function resolveObjectValue(
+  obj: Record<string, unknown>,
+  prop: PropertyNode,
+  params: Record<string, string>,
+  registry: TypeRegistry,
+): Expr {
+  // Find the target type — either from prop.type or registry lookup
+  let targetType = prop.type;
+  if (!targetType) {
+    targetType = registry.get(prop.typeName.name);
+  }
+
+  if (!targetType) {
+    throw new Error(
+      `Cannot resolve object for property '${prop.name}': type '${prop.typeName.name}' not found in registry`
+    );
+  }
+
+  return resolveObjectAgainstType(obj, targetType, params, registry);
+}
+
+/**
+ * Resolve an object against a known TypeNode.
+ * Handles discriminated unions (→ VariantConstruct) and plain types (→ Construct).
+ */
+function resolveObjectAgainstType(
+  obj: Record<string, unknown>,
+  targetType: TypeNode,
+  params: Record<string, string>,
+  registry: TypeRegistry,
+): Construct | VariantConstruct {
+  // Check for discriminated union dispatch
+  if (targetType.discriminator && targetType.childTypes.length > 0) {
+    const discriminatorValue = obj[targetType.discriminator];
+    if (typeof discriminatorValue === "string") {
+      return resolveVariantConstruct(obj, targetType, discriminatorValue, params, registry);
+    }
+  }
+
+  // Plain type — resolve all fields
+  return resolveConstruct(obj, targetType, params, registry);
+}
+
+/**
+ * Resolve a discriminated union variant.
+ * Looks up the child type by discriminator value, then resolves fields
+ * against the child type's properties.
+ */
+function resolveVariantConstruct(
+  obj: Record<string, unknown>,
+  baseType: TypeNode,
+  discriminatorValue: string,
+  params: Record<string, string>,
+  registry: TypeRegistry,
+): VariantConstruct {
+  // Find the child type matching this discriminator value
+  const childType = baseType.childTypes.find(child => {
+    const discProp = child.properties.find(p => p.name === baseType.discriminator);
+    return discProp?.defaultValue === discriminatorValue;
+  });
+
+  if (!childType) {
+    throw new Error(
+      `No child type of '${baseType.typeName.name}' has ${baseType.discriminator}='${discriminatorValue}'. ` +
+      `Available: [${baseType.childTypes.map(c => {
+        const dp = c.properties.find(p => p.name === baseType.discriminator);
+        return dp?.defaultValue ?? "*";
+      }).join(", ")}]`
+    );
+  }
+
+  // Resolve fields against the child type (excluding the discriminator itself)
+  const fields: FieldAssignment[] = [];
+  for (const [fieldName, value] of Object.entries(obj)) {
+    if (fieldName === baseType.discriminator) continue; // discriminator is implicit
+    // Look for the property on the child type first, then base type
+    const prop = childType.properties.find(p => p.name === fieldName)
+      ?? baseType.properties.find(p => p.name === fieldName);
+    if (!prop) {
+      throw new Error(
+        `Property '${fieldName}' not found on variant '${childType.typeName.name}' ` +
+        `or base '${baseType.typeName.name}'`
+      );
+    }
+    fields.push({
+      propertyName: fieldName,
+      value: resolveValue(value, prop, params, registry),
+      isOptional: prop.isOptional,
+    });
+  }
+
+  return {
+    kind: "variant",
+    baseTypeName: baseType.typeName,
+    discriminator: baseType.discriminator!,
+    discriminatorValue,
+    variantTypeName: childType.typeName,
+    fields,
+  };
+}
+
+/**
+ * Resolve a plain (non-polymorphic) object construction.
+ */
+function resolveConstruct(
+  obj: Record<string, unknown>,
+  targetType: TypeNode,
+  params: Record<string, string>,
+  registry: TypeRegistry,
+): Construct {
+  const fields: FieldAssignment[] = [];
+  for (const [fieldName, value] of Object.entries(obj)) {
+    const prop = targetType.properties.find(p => p.name === fieldName);
+    if (!prop) {
+      throw new Error(
+        `Property '${fieldName}' not found on type '${targetType.typeName.name}'. ` +
+        `Available: [${targetType.properties.map(p => p.name).join(", ")}]`
+      );
+    }
+    fields.push({
+      propertyName: fieldName,
+      value: resolveValue(value, prop, params, registry),
+      isOptional: prop.isOptional,
+    });
+  }
+
+  return {
+    kind: "construct",
+    typeName: targetType.typeName,
+    fields,
+  };
+}
+
+/**
+ * Check if a param name is used as a {placeholder} anywhere in the sets tree.
+ * Used to avoid double-emitting params that appear both as top-level property
+ * matches and as nested placeholders.
+ */
+function isParamConsumedInSets(paramName: string, sets: Record<string, unknown>): boolean {
+  const placeholder = `{${paramName}}`;
+  function search(value: unknown): boolean {
+    if (value === placeholder) return true;
+    if (Array.isArray(value)) return value.some(search);
+    if (value !== null && typeof value === "object") {
+      return Object.values(value as Record<string, unknown>).some(search);
+    }
+    return false;
+  }
+  return Object.values(sets).some(search);
+}
diff --git a/schema/emitter/src/ir/lower.ts b/schema/emitter/src/ir/lower.ts
new file mode 100644
index 00000000..94a8e5f8
--- /dev/null
+++ b/schema/emitter/src/ir/lower.ts
@@ -0,0 +1,538 @@
+/**
+ * Lowering pass — TypeNode graph → Declaration IR.
+ *
+ * This module converts the emitter's type graph (TypeNode/PropertyNode)
+ * into the language-agnostic Declaration IR (FileDecl/TypeDecl).
+ *
+ * The lowering is shared across all 5 target languages. Per-language
+ * emitter functions consume the FileDecl tree and emit code.
+ *
+ * Key responsibilities:
+ *   - Classify every property into a PropertyCategory
+ *   - Build load/save method specifications
+ *   - Resolve polymorphic dispatch
+ *   - Resolve collection helpers
+ *   - Resolve factory methods via the Expression IR
+ *   - Compute file-level imports
+ */
+
+import { TypeNode, PropertyNode, TypeName } from "./ast.js";
+import {
+  TypeRegistry,
+  resolveFactoryExpr,
+  collectExprTypeRefs,
+  Expr,
+} from "./expansion.js";
+import {
+  PropertyCategory,
+  FileDecl,
+  TypeDecl,
+  FieldDecl,
+  LoadDecl,
+  SaveDecl,
+  CoercionDecl,
+  CoercionAssignment,
+  LoadAssignment,
+  SaveAssignment,
+  PolymorphicDispatchDecl,
+  PolymorphicVariant,
+  PolymorphicDefault,
+  CollectionHelperDecl,
+  FactoryDecl,
+  MethodStubDecl,
+  ImportRef,
+  WireDecl,
+  WireFieldMapping,
+} from "./declarations.js";
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+/**
+ * Lower a base TypeNode (and all its children) into a FileDecl.
+ *
+ * This is the main entry point for the lowering pass. It produces a complete
+ * FileDecl containing one or more TypeDecls (parent + children for polymorphic types).
+ *
+ * The result is fully language-agnostic — per-language emitters handle rendering.
+ *
+ * @param node - The base TypeNode (must not have a parent — i.e., `node.base === null`)
+ * @param registry - TypeRegistry for resolving type references
+ * @param polymorphicTypeNames - Set of type names that are polymorphic bases
+ */
+export function lowerFile(
+  node: TypeNode,
+  registry: TypeRegistry,
+  polymorphicTypeNames?: Set<string>,
+): FileDecl {
+  const polyNames = polymorphicTypeNames ?? collectPolymorphicTypeNames(node, registry);
+
+  // Lower all types in this file (parent + children)
+  const types: TypeDecl[] = [
+    lowerType(node, registry, polyNames),
+    ...node.childTypes.map(ct => lowerType(ct, registry, polyNames)),
+  ];
+
+  // Resolve file-level imports
+  const imports = resolveImports(node, types, registry);
+
+  return {
+    typeName: node.typeName,
+    types,
+    imports,
+    containsAbstract: node.isAbstract || node.childTypes.some(c => c.isAbstract),
+  };
+}
+
+/**
+ * Collect all polymorphic type names from a set of nodes.
+ */
+export function collectPolymorphicTypeNames(
+  rootNode: TypeNode,
+  registry: TypeRegistry,
+): Set<string> {
+  const names = new Set<string>();
+
+  function walk(node: TypeNode): void {
+    if (node.discriminator && node.childTypes.length > 0) {
+      names.add(node.typeName.name);
+    }
+    for (const prop of node.properties) {
+      if (prop.type) walk(prop.type);
+    }
+    for (const child of node.childTypes) {
+      walk(child);
+    }
+  }
+
+  walk(rootNode);
+  return names;
+}
+
+// ============================================================================
+// Type lowering
+// ============================================================================
+
+/**
+ * Lower a single TypeNode into a TypeDecl.
+ */
+export function lowerType(
+  node: TypeNode,
+  registry: TypeRegistry,
+  polymorphicTypeNames: Set<string>,
+): TypeDecl {
+  const fields = node.properties.map(p => lowerField(p, polymorphicTypeNames));
+  const collectionHelpers = lowerCollectionHelpers(node);
+  const polymorphicDispatch = lowerPolymorphicDispatch(node);
+  const factories = lowerFactories(node, registry);
+  const coercionProperty = findCoercionProperty(node);
+
+  // Build load/save method specs
+  const load = lowerLoad(node, fields, polymorphicDispatch);
+  const save = lowerSave(node, fields);
+
+  return {
+    typeName: node.typeName,
+    base: node.base,
+    isAbstract: node.isAbstract,
+    isProtocol: node.isProtocol,
+    description: node.description,
+    fields,
+    coercionProperty,
+    load,
+    save,
+    factories,
+    collectionHelpers,
+    polymorphicDispatch,
+    methods: lowerMethods(node),
+    wire: lowerWire(node, fields),
+  };
+}
+
+// ============================================================================
+// Property classification — the core insight
+// ============================================================================
+
+/**
+ * Classify a property into one of 5 categories.
+ * This is the fundamental decision that drives ALL code generation.
+ *
+ * Decision tree:
+ *   isDict → "dict"
+ *   isCollection && isScalar → "collection_scalar"
+ *   isCollection && !isScalar → "collection_complex"
+ *   isScalar → "scalar"
+ *   !isScalar → "complex"
+ */
+export function classifyProperty(
+  prop: PropertyNode,
+  polymorphicTypeNames: Set<string>,
+): PropertyCategory {
+  if (prop.isDict) {
+    return { kind: "dict" };
+  }
+
+  if (prop.isCollection) {
+    if (prop.isScalar) {
+      return { kind: "collection_scalar", scalarType: prop.typeName.name };
+    }
+    return { kind: "collection_complex", typeName: prop.typeName.name };
+  }
+
+  if (prop.isScalar) {
+    return { kind: "scalar", scalarType: prop.typeName.name };
+  }
+
+  return { kind: "complex", typeName: prop.typeName.name };
+}
+
+// ============================================================================
+// Field lowering
+// ============================================================================
+
+/**
+ * Lower a PropertyNode into a FieldDecl.
+ */
+function lowerField(
+  prop: PropertyNode,
+  polymorphicTypeNames: Set<string>,
+): FieldDecl {
+  const knownAs: Record<string, string> = {};
+  for (const entry of prop.knownAs) {
+    knownAs[entry.provider] = entry.name;
+  }
+  return {
+    name: prop.name,
+    typeName: prop.typeName,
+    category: classifyProperty(prop, polymorphicTypeNames),
+    isOptional: prop.isOptional,
+    defaultValue: prop.defaultValue,
+    allowedValues: prop.allowedValues,
+    description: prop.description,
+    knownAs,
+  };
+}
+
+// ============================================================================
+// Load method lowering
+// ============================================================================
+
+/**
+ * Lower the load/deserialization method specification.
+ *
+ * Produces language-agnostic coercion and assignment data. Each emitter
+ * decides variable names, rendering, and expression formatting.
+ */
+function lowerLoad(
+  node: TypeNode,
+  fields: FieldDecl[],
+  polymorphicDispatch: PolymorphicDispatchDecl | null,
+): LoadDecl {
+  // Determine if this type has a discriminator with child variants
+  const hasDiscriminatorWithChildren =
+    node.discriminator != null &&
+    (node.childTypes?.length ?? 0) > 0;
+
+  const coercions: CoercionDecl[] = (node.coercions || []).map(c => {
+    // Build structured assignments from the expansion dict
+    const assignments: CoercionAssignment[] = Object.entries(c.expansion).map(
+      ([key, value]) => ({
+        fieldName: key,
+        isInput: value === "{value}",
+        literalValue: value === "{value}" ? undefined : String(value),
+      }),
+    );
+
+    // Determine if this coercion needs runtime dispatch:
+    // only when the discriminator field is set dynamically AND child types exist
+    const setsDiscriminator = node.discriminator != null &&
+      assignments.some(a => a.fieldName === node.discriminator && a.isInput);
+    const needsDispatch = setsDiscriminator && hasDiscriminatorWithChildren;
+
+    return {
+      scalarType: c.scalar,
+      assignments,
+      needsDispatch,
+    };
+  });
+
+  // Per-property load assignments
+  const assignments: LoadAssignment[] = fields.map(f => ({
+    sourceName: f.name,
+    fieldName: f.name,
+    category: f.category,
+    isOptional: f.isOptional,
+    parentTypeName: node.typeName.name,
+  }));
+
+  return {
+    coercions,
+    assignments,
+    hasPolymorphicDispatch: polymorphicDispatch !== null,
+    hasContextHooks: true, // All types support context hooks
+  };
+}
+
+// ============================================================================
+// Save method lowering
+// ============================================================================
+
+/**
+ * Lower the save/serialization method specification.
+ */
+function lowerSave(
+  node: TypeNode,
+  fields: FieldDecl[],
+): SaveDecl {
+  const assignments: SaveAssignment[] = fields.map(f => ({
+    targetName: f.name,
+    fieldName: f.name,
+    category: f.category,
+    isOptional: f.isOptional,
+    parentTypeName: node.typeName.name,
+  }));
+
+  return {
+    assignments,
+    hasBase: node.base !== null,
+    hasContextHooks: true,
+  };
+}
+
+// ============================================================================
+// Polymorphic dispatch lowering
+// ============================================================================
+
+/**
+ * Lower polymorphic dispatch specification from TypeNode.
+ * Returns null if the type is not polymorphic (no discriminator or no children).
+ */
+function lowerPolymorphicDispatch(
+  node: TypeNode,
+): PolymorphicDispatchDecl | null {
+  const polyTypes = node.retrievePolymorphicTypes();
+  if (!polyTypes) return null;
+
+  const variants: PolymorphicVariant[] = polyTypes.types.map((t: any) => ({
+    value: t.value,
+    typeName: (t.instance as TypeNode).typeName,
+  }));
+
+  let defaultVariant: PolymorphicDefault | null = null;
+  if (polyTypes.default) {
+    const defaultNode = polyTypes.default.instance as TypeNode;
+    defaultVariant = {
+      typeName: defaultNode.typeName,
+      isSelfReference: defaultNode.typeName.name === node.typeName.name,
+    };
+  }
+
+  const baseDispatch: PolymorphicDispatchDecl = {
+    discriminatorField: node.discriminator!,
+    variants,
+    defaultVariant,
+    isAbstract: node.isAbstract,
+  };
+
+  return baseDispatch;
+}
+
+// ============================================================================
+// Collection helper lowering
+// ============================================================================
+
+/**
+ * Lower collection helpers for complex collection properties.
+ * These are properties like `tools: Tool[]` or `parts: ContentPart[]`
+ * that need dedicated load/save helper methods for dict↔array conversion.
+ */
+function lowerCollectionHelpers(node: TypeNode): CollectionHelperDecl[] {
+  return node.properties
+    .filter(p => p.isCollection && !p.isScalar && !p.isDict)
+    .map(p => ({
+      propertyName: p.name,
+      elementTypeName: p.typeName,
+      innerFields: p.type?.properties.filter(t => t.name !== "name").map(t => t.name) || [],
+      hasNameProperty: p.type?.properties.some(t => t.name === "name") || false,
+    }));
+}
+
+// ============================================================================
+// Factory method lowering
+// ============================================================================
+
+/**
+ * Lower factory methods. Resolves the Expr tree via the Expression IR
+ * but stores it as a typed Expr (not pre-rendered string).
+ * Emitters will visit the Expr with their own visitor for language-specific output.
+ */
+function lowerFactories(
+  node: TypeNode,
+  registry: TypeRegistry,
+): FactoryDecl[] {
+  if (!node.factories || node.factories.length === 0) return [];
+
+  return node.factories.map(f => {
+    const expr = resolveFactoryExpr(f.sets, f.params, node, registry);
+
+    return {
+      name: f.name,
+      params: f.params,
+      body: expr,
+    };
+  });
+}
+
+// ============================================================================
+// Method stub lowering
+// ============================================================================
+
+function lowerMethods(node: TypeNode): MethodStubDecl[] {
+  return (node.methods || []).map(m => ({
+    name: m.name,
+    returns: m.returns,
+    description: m.description,
+    params: m.params || {},
+    optional: m.optional ?? false,
+    sync: m.sync ?? false,
+  }));
+}
+
+// ============================================================================
+// Wire conversion lowering
+// ============================================================================
+
+/**
+ * Lower wire conversion data from knownAs mappings on fields.
+ * Returns null if no field has wire mappings.
+ */
+function lowerWire(node: TypeNode, fields: FieldDecl[]): WireDecl | null {
+  const providerSet = new Set<string>();
+  const mappings: WireFieldMapping[] = [];
+
+  for (const field of fields) {
+    if (Object.keys(field.knownAs).length > 0) {
+      for (const provider of Object.keys(field.knownAs)) {
+        providerSet.add(provider);
+      }
+      mappings.push({
+        fieldName: field.name,
+        category: field.category,
+        isOptional: field.isOptional,
+        parentTypeName: node.typeName.name,
+        wireNames: field.knownAs,
+      });
+    }
+  }
+
+  if (mappings.length === 0) return null;
+
+  return {
+    providers: Array.from(providerSet).sort(),
+    mappings,
+  };
+}
+
+// ============================================================================
+// Coercion property detection
+// ============================================================================
+
+/**
+ * Find the property that receives "{value}" in coercion expansions.
+ */
+function findCoercionProperty(node: TypeNode): string | null {
+  if (!node.coercions || node.coercions.length === 0) return null;
+
+  for (const alt of node.coercions) {
+    for (const [key, value] of Object.entries(alt.expansion)) {
+      if (value === "{value}") {
+        return key;
+      }
+    }
+  }
+  return null;
+}
+
+// ============================================================================
+// Import resolution
+// ============================================================================
+
+/**
+ * Resolve file-level imports from type references.
+ * Groups imports by module: each module maps to the symbols imported from it.
+ */
+function resolveImports(
+  rootNode: TypeNode,
+  types: TypeDecl[],
+  registry: TypeRegistry,
+): ImportRef[] {
+  // Types defined in this file (excluded from imports)
+  const definedInFile = new Set([
+    rootNode.typeName.name,
+    ...rootNode.childTypes.map(c => c.typeName.name),
+  ]);
+  const importMap = new Map<string, Set<string>>();
+
+  const addImport = (typeName: string, module?: string) => {
+    if (definedInFile.has(typeName)) return;
+    // Determine which module this type lives in
+    const refNode = registry.get(typeName);
+    const mod = module ?? (refNode?.base ? refNode.base.name : typeName);
+    if (!importMap.has(mod)) importMap.set(mod, new Set());
+    importMap.get(mod)!.add(typeName);
+  };
+
+  // Collect import refs from all properties across all types in this file
+  for (const type of types) {
+    for (const field of type.fields) {
+      // Only import non-scalar, non-dict types
+      if (field.category.kind === "complex" || field.category.kind === "collection_complex") {
+        addImport(field.typeName.name);
+      }
+    }
+
+    // Factory-referenced imports (may include child types like TextPart)
+    for (const factory of type.factories) {
+      for (const ref of collectExprTypeRefs(factory.body)) {
+        if (definedInFile.has(ref.name)) continue;
+        addImport(ref.name);
+      }
+    }
+
+    // Protocol method type references (param types and return types)
+    for (const method of type.methods) {
+      for (const typeName of extractMethodTypeRefs(method)) {
+        addImport(typeName);
+      }
+    }
+  }
+
+  return Array.from(importMap.entries())
+    .map(([module, names]) => ({ module, names: Array.from(names).sort() }))
+    .sort((a, b) => a.module.localeCompare(b.module));
+}
+
+/**
+ * Extract type names referenced in method parameter types and return type.
+ * Handles formats like "Prompty", "Message[]", "Record<unknown>", "string", "unknown".
+ */
+function extractMethodTypeRefs(method: MethodStubDecl): string[] {
+  const SCALARS = new Set(["string", "int32", "float32", "float64", "boolean", "unknown"]);
+  const refs: string[] = [];
+
+  const extract = (typeStr: string) => {
+    // Strip nullable suffix and array suffix: "string?" → "string", "Message[]" → "Message"
+    const base = typeStr.replace(/\?$/, "").replace(/\[\]$/, "");
+    // Skip scalars, Record<>, and generic types
+    if (SCALARS.has(base) || base.startsWith("Record<")) return;
+    refs.push(base);
+  };
+
+  extract(method.returns);
+  for (const pType of Object.values(method.params)) {
+    extract(pType);
+  }
+
+  return refs;
+}
diff --git a/schema/emitter/src/utilities.ts b/schema/emitter/src/ir/utilities.ts
similarity index 100%
rename from schema/emitter/src/utilities.ts
rename to schema/emitter/src/ir/utilities.ts
diff --git a/schema/emitter/src/ir/visitor.ts b/schema/emitter/src/ir/visitor.ts
new file mode 100644
index 00000000..f4d5853a
--- /dev/null
+++ b/schema/emitter/src/ir/visitor.ts
@@ -0,0 +1,67 @@
+/**
+ * Expression visitor interface and shared helpers.
+ *
+ * The ExprVisitor interface is the contract between the shared IR and
+ * per-language code emitters. Each language implements its own visitor
+ * in `languages/<lang>/visitor.ts`.
+ */
+
+import { Expr, Construct, VariantConstruct, TypeRegistry } from "./expansion.js";
+
+// ============================================================================
+// Visitor interface
+// ============================================================================
+
+export interface ExprVisitor {
+  visitExpr(expr: Expr): string;
+  /** Optional type registry for wire format generation and type-aware codegen. */
+  registry?: TypeRegistry;
+}
+
+/**
+ * Render a Construct expression's fields as a plain object literal.
+ * Used by TypeScript, Python, C#, Go coercions where the template wraps
+ * the literal in language-specific loading logic (e.g., `TypeName.load({...}, ctx)`).
+ *
+ * @param expr - A Construct or VariantConstruct expression
+ * @param visitor - The language-specific visitor for rendering field values
+ * @param format - How to format the fields:
+ *   - "js": `{ field: value }` (TypeScript, Go)
+ *   - "py": `{"field": value}` (Python)
+ */
+export function renderObjectLiteral(
+  expr: Construct | VariantConstruct,
+  visitor: ExprVisitor,
+  format: "js" | "py" = "js",
+): string {
+  const fields = expr.fields.map(f => {
+    const val = visitor.visitExpr(f.value);
+    switch (format) {
+      case "js":
+        return `${f.propertyName}: ${val}`;
+      case "py":
+        return `"${f.propertyName}": ${val}`;
+    }
+  });
+  return `{ ${fields.join(", ")} }`;
+}
+
+// ============================================================================
+// Naming helpers — reusable across visitors
+// ============================================================================
+
+/** camelCase → PascalCase (first char uppercase). */
+export function toPascalCase(name: string): string {
+  // Handle snake_case first
+  if (name.includes("_")) {
+    return name
+      .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())
+      .replace(/^(.)/, (_, char) => char.toUpperCase());
+  }
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+/** Exhaustive check helper — TypeScript enforces all Expr.kind arms are handled. */
+export function assertNever(x: never): never {
+  throw new Error(`Unexpected expression kind: ${(x as Expr).kind}`);
+}
diff --git a/schema/emitter/src/languages/csharp/driver.ts b/schema/emitter/src/languages/csharp/driver.ts
new file mode 100644
index 00000000..8eeb3b81
--- /dev/null
+++ b/schema/emitter/src/languages/csharp/driver.ts
@@ -0,0 +1,261 @@
+import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
+import { EmitTarget, PromptyEmitterOptions } from "../../lib.js";
+import { enumerateTypes, TypeNode } from "../../ir/ast.js";
+import { GeneratorOptions, filterNodes } from "../../emitter.js";
+import { getCombinations, scalarValue } from "../../ir/utilities.js";
+import * as YAML from "yaml";
+import { resolve, dirname } from "path";
+import { execFileSync } from "child_process";
+import { existsSync, readdirSync } from "fs";
+import { TypeRegistry } from "../../ir/expansion.js";
+import { CSharpExprVisitor } from "./visitor.js";
+import { lowerType, collectPolymorphicTypeNames } from "../../ir/lower.js";
+import { emitCSharpClass } from "./emitter.js";
+import { emitCSharpContext, emitCSharpUtils } from "./scaffolding.js";
+import { emitCSharpTest } from "./test-emitter.js";
+
+export const generateCsharp = async (context: EmitContext<PromptyEmitterOptions>, node: TypeNode, emitTarget: EmitTarget, options?: GeneratorOptions) => {
+  const allTypes = Array.from(enumerateTypes(node));
+  const nodes = filterNodes(allTypes, options);
+
+  // Build the expression IR infrastructure
+  const registry = TypeRegistry.fromTypeGraph(allTypes);
+  const visitor = new CSharpExprVisitor(registry);
+
+  // Determine namespace: use explicit override from config, or fall back to TypeSpec namespace
+  const originalNamespace = node.typeName.namespace;
+  const csharpNamespace = emitTarget.namespace ?? originalNamespace;
+
+  // Emit context classes (LoadContext, SaveContext)
+  const contextCode = emitCSharpContext(csharpNamespace);
+  await emitCsharpFile(context, node, contextCode, "Context.cs", emitTarget["output-dir"]);
+
+  const utils = emitCSharpUtils(csharpNamespace);
+
+  await emitCsharpFile(context, node, utils, "Utils.cs", emitTarget["output-dir"]);
+
+  // Build Declaration IR once (loop-invariant)
+  const polyNames = collectPolymorphicTypeNames(allTypes[0], registry);
+  const allTypeDecls = nodes.map(nd => lowerType(nd, registry, polyNames));
+  const findTypeDecl = (name: string) => allTypeDecls.find(t => t.typeName.name === name);
+
+  for (const n of nodes) {
+    const typeDecl = lowerType(n, registry, polyNames);
+    const classCode = emitCSharpClass(typeDecl, csharpNamespace, visitor, allTypeDecls, findTypeDecl);
+    await emitCsharpFile(context, n, classCode, `${n.typeName.name}.cs`, emitTarget["output-dir"]);
+    if (emitTarget["test-dir"] && !n.isProtocol) {
+      await emitCsharpFile(context, n, renderTests(n, csharpNamespace), `${n.typeName.name}ConversionTests.cs`, emitTarget["test-dir"]);
+    }
+  }
+
+  // Format emitted files if format option is enabled (default: true)
+  if (emitTarget.format !== false) {
+    const outputDir = emitTarget["output-dir"]
+      ? resolve(process.cwd(), emitTarget["output-dir"])
+      : context.emitterOutputDir;
+    const testDir = emitTarget["test-dir"]
+      ? resolve(process.cwd(), emitTarget["test-dir"])
+      : undefined;
+
+    formatCSharpFiles(outputDir, testDir);
+  }
+};
+
+
+// --- Test-rendering helpers ---
+
+const renderTests = (node: TypeNode, namespace: string): string => {
+  const samples = node.properties.filter(p => p.samples && p.samples.length > 0).map(p => {
+    return p.samples?.map(s => ({
+      ...s.sample,
+    }));
+  });
+
+  const combinations =
+    samples.length > 0 ?
+      getCombinations(samples) :
+      [];
+
+  const examples = combinations.map(c => {
+    const sample = Object.assign({}, ...c);
+    // Create YAML document and customize string scalar style for values with special chars
+    const doc = new YAML.Document(sample);
+    YAML.visit(doc, {
+      Scalar(key, node) {
+        // Only quote string values that contain special characters requiring escaping
+        if (typeof node.value === 'string') {
+          const str = node.value as string;
+          if (str.includes('\n') || str.includes('\t') || str.includes('#') || str.includes(':') || str.includes('"')) {
+            node.type = 'QUOTE_DOUBLE';
+          }
+        }
+      }
+    });
+    return {
+      json: JSON.stringify(sample, null, 2).split('\n'),
+      yaml: doc.toString({ indent: 2, lineWidth: 0 }).split('\n'),
+      // get all scalars in the sample - using 'validations' (plural) for consistency across languages
+      validations: Object.keys(sample).filter(key => typeof sample[key] !== 'object').map(key => {
+        const val = sample[key];
+        const needsVerbatim = typeof val === 'string' && (val.includes('\n') || val.includes('"'));
+        return {
+          key: renderName(key),
+          value: typeof val === 'boolean' ? (val ? "True" : "False") :
+            (needsVerbatim ? (val as string).replace(/"/g, '""') : val),
+          startDelim: typeof val === 'string' ? (needsVerbatim ? '@"' : '"') : '',
+          endDelim: typeof val === 'string' ? '"' :
+            typeof val === 'number' && !Number.isInteger(val) ? 'f' : '',
+        };
+      }),
+    };
+  });
+
+  const coercions = node.coercions.map(alt => {
+    const example = alt.example ? (typeof (alt.example) === "string" ? '"' + alt.example + '"' : alt.example.toString()) : scalarValue[alt.scalar] || "None";
+    return {
+      title: alt.title || alt.scalar,
+      scalar: alt.scalar,
+      value: example,
+      // using 'validations' (plural) for consistency across languages
+      validations: Object.keys(alt.expansion).filter(key => typeof alt.expansion[key] !== 'object').map(key => {
+        const value = alt.expansion[key] === "{value}" ? example : alt.expansion[key];
+        return {
+          key: renderName(key),
+          value: value,
+          delimiter: typeof value === 'string' && !value.includes('"') && alt.expansion[key] !== "{value}" ? '"' : '',
+        };
+      }),
+    };
+  });
+
+  return emitCSharpTest({
+    node,
+    namespace,
+    examples,
+    coercions,
+    factories: node.factories,
+    renderName,
+    renderCsharpFactoryMethodName: (factoryName: string) => renderCsharpFactoryMethodName(factoryName, node),
+    renderCsharpFactoryTestValue,
+  });
+};
+
+const renderName = (name: string): string => {
+  // convert snake_case to PascalCase
+  const pascal = name.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  // capitalize the first letter
+  return pascal.charAt(0).toUpperCase() + pascal.slice(1);
+};
+
+const renderCsharpFactoryParamType = (typeStr: string): string => {
+  switch (typeStr) {
+    case "string": return "string";
+    case "boolean": return "bool";
+    case "integer": case "int32": return "int";
+    case "int64": return "long";
+    case "float": case "float32": return "float";
+    case "float64": return "double";
+    case "unknown": return "object?";
+    default: return "object?";
+  }
+};
+
+// Returns a factory method name that won't clash with C# property names on the same type.
+// If the capitalized factory name matches a property name, prefix with "Create".
+const renderCsharpFactoryMethodName = (factoryName: string, node: TypeNode): string => {
+  const methodName = factoryName.charAt(0).toUpperCase() + factoryName.slice(1);
+  const propertyNames = node.properties.map(p => renderName(p.name));
+  if (propertyNames.includes(methodName)) {
+    return `Create${methodName}`;
+  }
+  return methodName;
+};
+
+const renderCsharpFactoryTestValue = (typeStr: string): string => {
+  switch (typeStr) {
+    case "string": return '"test"';
+    case "boolean": return "true";
+    case "integer": case "int32": return "42";
+    case "int64": return "42L";
+    case "float": case "float32": return "3.14f";
+    case "float64": return "3.14";
+    case "unknown": return '"test"';
+    default: return '"test"';
+  }
+};
+
+
+const emitCsharpFile = async (context: EmitContext<PromptyEmitterOptions>, type: TypeNode, python: string, filename: string, outputDir?: string) => {
+  outputDir = outputDir || `${context.emitterOutputDir}/CSharp`;
+  const typePath = type.typeName.namespace.split(".");
+
+  // replace typename with file
+  typePath.push(filename);
+  const path = resolvePath(outputDir, filename);
+  await emitFile(context.program, {
+    path,
+    content: python,
+  });
+}
+
+/**
+ * Format C# files using dotnet format.
+ * Runs formatter from the .NET project root (where .csproj or .sln is located).
+ */
+function formatCSharpFiles(outputDir: string, testDir?: string): void {
+  const dirs = [outputDir, ...(testDir ? [testDir] : [])];
+  const formatted = new Set<string>();
+
+  for (const dir of dirs) {
+    const projectRoot = findDotNetProjectRoot(dir);
+    if (!projectRoot) {
+      console.warn(`Warning: Could not find .csproj or .sln file for ${dir}. Skipping formatting.`);
+      continue;
+    }
+
+    // Avoid formatting the same project twice
+    if (formatted.has(projectRoot)) {
+      continue;
+    }
+    formatted.add(projectRoot);
+
+    try {
+      execFileSync("dotnet", ["format", projectRoot], {
+        cwd: dirname(projectRoot),
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      });
+    } catch (error) {
+      console.warn(`Warning: dotnet format failed for ${projectRoot}. You may need to run it manually.`);
+    }
+  }
+}
+
+/**
+ * Find the .NET project root by traversing up from the output directory
+ * looking for .csproj or .sln files.
+ */
+function findDotNetProjectRoot(startDir: string): string | undefined {
+  let currentDir = resolve(startDir);
+  const root = resolve('/');
+
+  // On Windows, also check for drive root (e.g., "C:\")
+  while (currentDir !== root && currentDir !== dirname(currentDir)) {
+    // First check for .csproj (more specific)
+    const files = existsSync(currentDir) ? readdirSync(currentDir) : [];
+    const csprojFile = files.find((f: string) => f.endsWith('.csproj'));
+    if (csprojFile) {
+      return resolve(currentDir, csprojFile);
+    }
+
+    // Then check for .sln
+    const slnFile = files.find((f: string) => f.endsWith('.sln'));
+    if (slnFile) {
+      return resolve(currentDir, slnFile);
+    }
+
+    currentDir = dirname(currentDir);
+  }
+
+  return undefined;
+}
diff --git a/schema/emitter/src/languages/csharp/emitter.ts b/schema/emitter/src/languages/csharp/emitter.ts
new file mode 100644
index 00000000..ac18f43e
--- /dev/null
+++ b/schema/emitter/src/languages/csharp/emitter.ts
@@ -0,0 +1,1267 @@
+/**
+ * C# code emitter — Declaration IR → C# source code.
+ *
+ * Replaces `file.cs.njk` Nunjucks template with a typed TypeScript function
+ * that walks the TypeDecl tree and produces a complete C# class file.
+ *
+ * Each TypeDecl becomes one C# file (one class per file).
+ * Polymorphic types use abstract class + child : Base inheritance.
+ *
+ * Structural blocks emitted (in order):
+ *   1. Copyright + using directives
+ *   2. Namespace
+ *   3. XML doc comment
+ *   4. Class declaration
+ *   5. ShorthandProperty
+ *   6. Constructor
+ *   7. Properties
+ *   8. #region Load Methods
+ *   9. #region Save Methods
+ *  10. #region Factory Methods (if any)
+ *  11. #region Helpers (if any)
+ */
+
+import {
+  TypeDecl,
+  FieldDecl,
+  LoadAssignment,
+  SaveAssignment,
+  CollectionHelperDecl,
+  PolymorphicDispatchDecl,
+  FactoryDecl,
+  CoercionDecl,
+  CoercionAssignment,
+  PropertyCategory,
+  MethodStubDecl,
+} from "../../ir/declarations.js";
+import { ExprVisitor, toPascalCase } from "../../ir/visitor.js";
+
+// ============================================================================
+// Type maps
+// ============================================================================
+
+const CSHARP_TYPE_MAP: Record<string, string> = {
+  string: "string",
+  number: "float",
+  boolean: "bool",
+  int32: "int",
+  int64: "long",
+  float32: "float",
+  float64: "double",
+  integer: "int",
+  object: "object",
+  unknown: "object",
+  any: "object",
+  dictionary: "IDictionary<string, object>",
+  array: "IList<object>",
+};
+
+const CONVERT_MAP: Record<string, string> = {
+  bool: "Boolean",
+  int: "Int32",
+  long: "Int64",
+  float: "Single",
+  double: "Double",
+};
+
+const NON_NULLABLE_VALUE_TYPES = new Set(["bool", "int", "long", "float", "double"]);
+
+// ============================================================================
+// Main entry point
+// ============================================================================
+
+/**
+ * Emit a complete C# class file for a single TypeDecl.
+ */
+export function emitCSharpClass(
+  type: TypeDecl,
+  namespace: string,
+  visitor: ExprVisitor,
+  allTypes: TypeDecl[],
+  findType: (name: string) => TypeDecl | undefined,
+): string {
+  const lines: string[] = [];
+
+  // Protocol types → emit as interface
+  if (type.isProtocol) {
+    return emitCSharpInterface(type, namespace, lines);
+  }
+
+  // Header
+  emitHeader(lines, namespace);
+
+  // Class doc comment
+  emitXmlDocComment(type.description, "    ", lines);
+
+  // Class declaration
+  emitClassDeclaration(type, lines);
+
+  // ShorthandProperty
+  emitShorthandProperty(type, lines);
+
+  // Constructor
+  emitConstructor(type, lines);
+
+  // Properties
+  emitProperties(type, allTypes, findType, lines);
+
+  // Load region
+  emitLoadRegion(type, allTypes, findType, lines);
+
+  // Save region
+  emitSaveRegion(type, allTypes, findType, lines);
+
+  // Factory methods
+  if (type.factories.length > 0) {
+    emitFactoryRegion(type, visitor, lines);
+  }
+
+  // Helper stubs
+  if (type.methods.length > 0) {
+    emitHelperRegion(type, lines);
+  }
+
+  // Close class
+  lines.push("}");
+
+  // Emit I<Name>Helpers interface after the class
+  if (type.methods.length > 0) {
+    emitHelperInterface(type, lines);
+  }
+
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// ============================================================================
+// Protocol interface emission
+// ============================================================================
+
+/** Map a protocol type string to a C# type. */
+function protocolCSharpType(typeStr: string): string {
+  // Handle array types
+  if (typeStr.endsWith("[]")) {
+    const inner = typeStr.slice(0, -2);
+    return `List<${protocolCSharpType(inner)}>`;
+  }
+  if (typeStr === "Record<unknown>" || typeStr === "dictionary") return "Dictionary<string, object?>";
+  if (typeStr === "unknown" || typeStr === "any") return "object";
+  // Handle nullable types (e.g., "string?")
+  if (typeStr.endsWith("?")) {
+    const inner = typeStr.slice(0, -1);
+    return `${protocolCSharpType(inner)}?`;
+  }
+  return CSHARP_TYPE_MAP[typeStr] || typeStr;
+}
+
+/**
+ * Emit a C# interface for a protocol type.
+ */
+function emitCSharpInterface(type: TypeDecl, namespace: string, lines: string[]): string {
+  const name = type.typeName.name;
+
+  // Header (simplified — no YAML/JSON imports needed for interfaces)
+  lines.push("// Copyright (c) Microsoft. All rights reserved.");
+  lines.push("");
+  lines.push("#pragma warning disable IDE0130");
+  lines.push(`namespace ${namespace};`);
+  lines.push("#pragma warning restore IDE0130");
+  lines.push("");
+
+  // XML doc
+  if (type.description) {
+    emitXmlDocComment(type.description, "    ", lines);
+  }
+  lines.push(`    public interface I${name}`);
+  lines.push("    {");
+
+  for (const method of type.methods) {
+    if (method.description) {
+      emitXmlDocComment(method.description, "        ", lines);
+    }
+    const params = Object.entries(method.params)
+      .map(([pName, pType]) => `${protocolCSharpType(pType)} ${pName}`)
+      .join(", ");
+    const ret = protocolCSharpType(method.returns);
+
+    if (method.sync) {
+      // Synchronous method
+      if (method.optional) {
+        // Return type already includes nullability — provide default body
+        lines.push(`        ${ret} ${toPascalCase(method.name)}(${params}) => default;`);
+      } else {
+        lines.push(`        ${ret} ${toPascalCase(method.name)}(${params});`);
+      }
+    } else {
+      // Async method
+      if (method.optional) {
+        lines.push(`        Task<${ret}> ${toPascalCase(method.name)}Async(${params}) => Task.FromResult<${ret}>(default);`);
+      } else {
+        lines.push(`        Task<${ret}> ${toPascalCase(method.name)}Async(${params});`);
+      }
+    }
+  }
+
+  lines.push("    }");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// ============================================================================
+// Header & namespace
+// ============================================================================
+
+function emitHeader(lines: string[], namespace: string): void {
+  lines.push("// Copyright (c) Microsoft. All rights reserved.");
+  lines.push("using System.Text.Json;");
+  lines.push("using YamlDotNet.Serialization;");
+  lines.push("");
+  lines.push("#pragma warning disable IDE0130");
+  lines.push(`namespace ${namespace};`);
+  lines.push("#pragma warning restore IDE0130");
+  lines.push("");
+}
+
+// ============================================================================
+// XML doc comment
+// ============================================================================
+
+function emitXmlDocComment(description: string, indent: string, lines: string[]): void {
+  lines.push(`${indent}/// <summary>`);
+  // Split multi-line descriptions into separate /// lines
+  const descLines = description.split(/\r?\n/).map(l => l.trim()).filter(l => l.length > 0);
+  for (let i = 0; i < descLines.length; i++) {
+    lines.push(`${indent}/// ${descLines[i]}`);
+    // Add empty /// line between paragraphs (if multiple lines and not the last)
+    if (descLines.length > 1 && i < descLines.length - 1) {
+      lines.push(`${indent}/// `);
+    }
+  }
+  lines.push(`${indent}/// </summary>`);
+}
+
+// ============================================================================
+// Class declaration
+// ============================================================================
+
+function emitClassDeclaration(type: TypeDecl, lines: string[]): void {
+  const abstract_ = type.isAbstract ? "abstract " : "";
+  const bases: string[] = [];
+  if (type.base) bases.push(type.base.name);
+  if (type.methods.length > 0) bases.push(`I${type.typeName.name}Helpers`);
+  const baseSuffix = bases.length > 0 ? ` : ${bases.join(", ")}` : "";
+  lines.push(`public ${abstract_}partial class ${type.typeName.name}${baseSuffix}`);
+  lines.push("{");
+}
+
+// ============================================================================
+// ShorthandProperty
+// ============================================================================
+
+function emitShorthandProperty(type: TypeDecl, lines: string[]): void {
+  const new_ = type.base ? "new " : "";
+  const value = type.coercionProperty ? `"${type.coercionProperty}"` : "null";
+  lines.push("    /// <summary>");
+  lines.push("    /// The shorthand property name for this type, if any.");
+  lines.push("    /// </summary>");
+  lines.push(`    public ${new_}static string? ShorthandProperty => ${value};`);
+  lines.push("");
+}
+
+// ============================================================================
+// Constructor
+// ============================================================================
+
+function emitConstructor(type: TypeDecl, lines: string[]): void {
+  const access = type.isAbstract ? "protected" : "public";
+  lines.push("    /// <summary>");
+  lines.push(`    /// Initializes a new instance of <see cref="${type.typeName.name}"/>.`);
+  lines.push("    /// </summary>");
+  lines.push("#pragma warning disable CS8618");
+  lines.push(`    ${access} ${type.typeName.name}()`);
+  lines.push("    {");
+  lines.push("    }");
+  lines.push("#pragma warning restore CS8618");
+  lines.push("");
+}
+
+// ============================================================================
+// Properties
+// ============================================================================
+
+function emitProperties(type: TypeDecl, allTypes: TypeDecl[], findType: (name: string) => TypeDecl | undefined, lines: string[]): void {
+  for (const field of type.fields) {
+    const modifier = getPropertyModifier(field, type, allTypes, findType);
+    const csType = getCSharpType(field.category, field.isOptional);
+    const propName = toPascalCase(field.name);
+    const default_ = getPropertyDefault(field);
+
+    emitXmlDocComment(field.description || propName, "    ", lines);
+    lines.push(`    public ${modifier}${csType} ${propName} { get; set; }${default_}`);
+    lines.push("");
+  }
+  lines.push("");
+}
+
+function getPropertyModifier(
+  field: FieldDecl,
+  type: TypeDecl,
+  allTypes: TypeDecl[],
+  findType: (name: string) => TypeDecl | undefined,
+): string {
+  // Check if any child type has a field with same name → virtual
+  if (type.polymorphicDispatch || type.isAbstract) {
+    const childHasSameField = allTypes.some(t =>
+      t.base?.name === type.typeName.name &&
+      t.fields.some(f => f.name === field.name)
+    );
+    if (childHasSameField) return "virtual ";
+  }
+
+  // Check if parent has same field → override
+  if (type.base) {
+    const parent = findType(type.base.name);
+    if (parent?.fields.some(f => f.name === field.name)) {
+      return "override ";
+    }
+  }
+
+  return "";
+}
+
+function getCSharpType(category: PropertyCategory, isOptional: boolean): string {
+  let baseType: string;
+  switch (category.kind) {
+    case "scalar":
+      baseType = CSHARP_TYPE_MAP[category.scalarType] || "object";
+      break;
+    case "complex":
+      baseType = category.typeName;
+      break;
+    case "collection_scalar": {
+      const inner = CSHARP_TYPE_MAP[category.scalarType] || "object";
+      baseType = `IList<${inner}>`;
+      break;
+    }
+    case "collection_complex":
+      baseType = `IList<${category.typeName}>`;
+      break;
+    case "dict":
+      baseType = "IDictionary<string, object>";
+      break;
+  }
+  return isOptional ? `${baseType}?` : baseType;
+}
+
+function getPropertyDefault(field: FieldDecl): string {
+  if (field.isOptional) return "";
+
+  const cat = field.category;
+  switch (cat.kind) {
+    case "collection_scalar":
+    case "collection_complex":
+      return " = [];";
+    case "dict":
+      return " = new Dictionary<string, object>();";
+    case "scalar": {
+      const csType = CSHARP_TYPE_MAP[cat.scalarType] || "object";
+      if (csType === "string") {
+        if (field.defaultValue && field.defaultValue !== "*") {
+          return ` = "${field.defaultValue}";`;
+        }
+        return " = string.Empty;";
+      }
+      if (csType === "bool") {
+        return field.defaultValue != null ? ` = ${field.defaultValue};` : " = false;";
+      }
+      if (csType === "object") {
+        return " = new object();";
+      }
+      // number types: only emit default if there is one
+      if (field.defaultValue != null) {
+        return ` = ${field.defaultValue};`;
+      }
+      return "";
+    }
+    case "complex":
+      return "";
+  }
+}
+
+// ============================================================================
+// Load region
+// ============================================================================
+
+function emitLoadRegion(
+  type: TypeDecl,
+  allTypes: TypeDecl[],
+  findType: (name: string) => TypeDecl | undefined,
+  lines: string[],
+): void {
+  lines.push("");
+  lines.push("    #region Load Methods");
+  lines.push("");
+
+  // Main Load method
+  emitLoadMethod(type, allTypes, findType, lines);
+
+  // Collection load helpers
+  for (const helper of type.collectionHelpers) {
+    emitCollectionLoadHelper(helper, findType, lines);
+  }
+
+  // Polymorphic dispatch (LoadKind)
+  if (type.polymorphicDispatch) {
+    emitLoadKind(type, lines);
+  }
+
+  lines.push("");
+  lines.push("    #endregion");
+  lines.push("");
+}
+
+function emitLoadMethod(
+  type: TypeDecl,
+  allTypes: TypeDecl[],
+  findType: (name: string) => TypeDecl | undefined,
+  lines: string[],
+): void {
+  const typeName = type.typeName.name;
+  const new_ = type.base ? "new " : "";
+  const hasCoercions = type.load.coercions.length > 0 || type.coercionProperty;
+
+  lines.push("    /// <summary>");
+  lines.push(`    /// Load a ${typeName} instance from a dictionary.`);
+  lines.push("    /// </summary>");
+  lines.push('    /// <param name="data">The dictionary containing the data.</param>');
+  lines.push('    /// <param name="context">Optional context with pre/post processing callbacks.</param>');
+  lines.push(`    /// <returns>The loaded ${typeName} instance.</returns>`);
+  lines.push(`    public ${new_}static ${typeName} Load(Dictionary<string, object?> data, LoadContext? context = null)`);
+  lines.push("    {");
+
+  // ProcessInput
+  lines.push("        if (context is not null)");
+  lines.push("        {");
+  lines.push("            data = context.ProcessInput(data);");
+  lines.push("        }");
+  lines.push("");
+
+  // Note about alternate representations
+  if (hasCoercions) {
+    lines.push("        // Note: Alternate (shorthand) representations are handled by the converter");
+  }
+
+  lines.push("");
+
+  // Instance creation: polymorphic dispatch or direct
+  if (type.polymorphicDispatch) {
+    lines.push(`        // Load polymorphic ${typeName} instance`);
+    lines.push("        var instance = LoadKind(data, context);");
+  } else {
+    lines.push("        // Create new instance");
+    lines.push(`        var instance = new ${typeName}();`);
+  }
+
+  lines.push("");
+  lines.push("");
+
+  // Per-field assignments
+  for (const assign of type.load.assignments) {
+    emitLoadAssignment(assign, findType, lines);
+  }
+
+  // ProcessOutput
+  lines.push("        if (context is not null)");
+  lines.push("        {");
+  lines.push(`            instance = context.ProcessOutput(instance);`);
+  lines.push("        }");
+  lines.push("        return instance;");
+  lines.push("    }");
+  lines.push("");
+}
+
+function emitLoadAssignment(
+  assign: LoadAssignment,
+  findType: (name: string) => TypeDecl | undefined,
+  lines: string[],
+): void {
+  const propName = toPascalCase(assign.fieldName);
+  const varName = `${assign.sourceName}Value`;
+
+  lines.push(`        if (data.TryGetValue("${assign.sourceName}", out var ${varName}) && ${varName} is not null)`);
+  lines.push("        {");
+  lines.push(`            ${getLoadExpression(assign, propName, varName, findType)}`);
+  lines.push("        }");
+  lines.push("");
+}
+
+function getLoadExpression(
+  assign: LoadAssignment,
+  propName: string,
+  varName: string,
+  findType: (name: string) => TypeDecl | undefined,
+): string {
+  const cat = assign.category;
+  switch (cat.kind) {
+    case "scalar": {
+      const csType = CSHARP_TYPE_MAP[cat.scalarType] || "object";
+      if (csType === "string") {
+        return `instance.${propName} = ${varName}?.ToString()!;`;
+      }
+      if (NON_NULLABLE_VALUE_TYPES.has(csType)) {
+        const convertMethod = CONVERT_MAP[csType];
+        return `instance.${propName} = Convert.To${convertMethod}(${varName});`;
+      }
+      // object/unknown
+      return `instance.${propName} = ${varName};`;
+    }
+    case "dict":
+      return `instance.${propName} = ${varName}.GetDictionary()!;`;
+    case "complex":
+      return `instance.${propName} = ${cat.typeName}.Load(${varName}.GetDictionary(${cat.typeName}.ShorthandProperty), context);`;
+    case "collection_complex":
+      return `instance.${propName} = Load${propName}(${varName}, context);`;
+    case "collection_scalar": {
+      const csType = CSHARP_TYPE_MAP[cat.scalarType] || "object";
+      if (csType === "string") {
+        return `instance.${propName} = (${varName} as IEnumerable<object>)?.Select(x => x?.ToString()!).ToList() ?? [];`;
+      }
+      if (NON_NULLABLE_VALUE_TYPES.has(csType)) {
+        const convertMethod = CONVERT_MAP[csType];
+        return `instance.${propName} = (${varName} as IEnumerable<object>)?.Select(x => Convert.To${convertMethod}(x)).ToList() ?? [];`;
+      }
+      return `instance.${propName} = (${varName} as IEnumerable<object>)?.ToList() ?? [];`;
+    }
+  }
+}
+
+// ============================================================================
+// Collection Load Helper
+// ============================================================================
+
+function emitCollectionLoadHelper(
+  helper: CollectionHelperDecl,
+  findType: (name: string) => TypeDecl | undefined,
+  lines: string[],
+): void {
+  const propName = toPascalCase(helper.propertyName);
+  const elemType = helper.elementTypeName.name;
+
+  // Determine primary property for scalar shorthand in dict format
+  const elemTypeDecl = findType(elemType);
+  let primaryProp: string | null = null;
+  if (elemTypeDecl?.coercionProperty) {
+    primaryProp = elemTypeDecl.coercionProperty;
+  } else if (helper.innerFields.length > 0) {
+    primaryProp = helper.innerFields[0];
+  }
+
+  lines.push("");
+  lines.push("    /// <summary>");
+  lines.push(`    /// Load a list of ${elemType} from a dictionary or list.`);
+  lines.push("    /// </summary>");
+  lines.push(`    public static IList<${elemType}> Load${propName}(object data, LoadContext? context)`);
+  lines.push("    {");
+  lines.push(`        var result = new List<${elemType}>();`);
+  lines.push("");
+  lines.push("        if (data is Dictionary<string, object?> dict)");
+  lines.push("        {");
+  lines.push("            // Convert named dictionary to list");
+  lines.push("            foreach (var kvp in dict)");
+  lines.push("            {");
+  lines.push("                if (kvp.Value is IEnumerable<object>)");
+  lines.push("                {");
+  lines.push("                    throw new ArgumentException(");
+  lines.push(`                        $"Invalid '${helper.propertyName}' format: key '{kvp.Key}' has an array value. " +`);
+  lines.push(`                        $"'${helper.propertyName}' must be a flat list of objects or a name-keyed dict — " +`);
+  lines.push(`                        "not a nested {" + kvp.Key + ": [...]} structure.");`);
+  lines.push("                }");
+  lines.push("                var itemDict = kvp.Value.GetDictionary();");
+  lines.push("                if (itemDict.Count > 0)");
+  lines.push("                {");
+  lines.push("                    // Value is an object, add name to it");
+  lines.push('                    itemDict["name"] = kvp.Key;');
+  lines.push(`                    result.Add(${elemType}.Load(itemDict, context));`);
+  lines.push("                }");
+  lines.push("                else");
+  lines.push("                {");
+  lines.push("                    // Value is a scalar, use it as the primary property");
+  lines.push("                    var newDict = new Dictionary<string, object?>");
+  lines.push("                    {");
+  lines.push('                        ["name"] = kvp.Key,');
+  lines.push(`                        ["${primaryProp || ""}"] = kvp.Value`);
+  lines.push("                    };");
+  lines.push(`                    result.Add(${elemType}.Load(newDict, context));`);
+  lines.push("                }");
+  lines.push("            }");
+  lines.push("        }");
+  lines.push("        else if (data is IEnumerable<object> list)");
+  lines.push("        {");
+  lines.push("            foreach (var item in list)");
+  lines.push("            {");
+  lines.push(`                var itemDict = item.GetDictionary(${elemType}.ShorthandProperty);`);
+  lines.push("                if (itemDict.Count > 0)");
+  lines.push("                {");
+  lines.push(`                    result.Add(${elemType}.Load(itemDict, context));`);
+  lines.push("                }");
+  lines.push("            }");
+  lines.push("        }");
+  lines.push("");
+  lines.push("        return result;");
+  lines.push("    }");
+  lines.push("");
+}
+
+// ============================================================================
+// LoadKind (polymorphic dispatch)
+// ============================================================================
+
+function emitLoadKind(type: TypeDecl, lines: string[]): void {
+  const dispatch = type.polymorphicDispatch!;
+  const typeName = type.typeName.name;
+
+  lines.push("");
+  lines.push("    /// <summary>");
+  lines.push(`    /// Load polymorphic ${typeName} based on discriminator.`);
+  lines.push("    /// </summary>");
+  lines.push(`    private static ${typeName} LoadKind(Dictionary<string, object?> data, LoadContext? context)`);
+  lines.push("    {");
+  lines.push(`        if (data.TryGetValue("${dispatch.discriminatorField}", out var discriminatorValue) && discriminatorValue is not null)`);
+  lines.push("        {");
+  lines.push("            var discriminator = discriminatorValue.ToString()?.ToLowerInvariant();");
+  lines.push("            return discriminator switch");
+  lines.push("            {");
+
+  for (const variant of dispatch.variants) {
+    lines.push(`                "${variant.value}" => ${variant.typeName.name}.Load(data, context),`);
+  }
+
+  // Default handling
+  if (dispatch.defaultVariant) {
+    if (dispatch.defaultVariant.isSelfReference) {
+      lines.push(`                _ => new ${typeName}(),`);
+    } else {
+      lines.push(`                _ => ${dispatch.defaultVariant.typeName.name}.Load(data, context),`);
+    }
+  } else if (dispatch.isAbstract) {
+    lines.push(`                _ => throw new ArgumentException($"Unknown ${typeName} discriminator value: {discriminator}"),`);
+  } else {
+    lines.push(`                _ => new ${typeName}(),`);
+  }
+
+  lines.push("            };");
+  lines.push("        }");
+  lines.push("");
+
+  // Fallback when discriminator property is missing
+  if (dispatch.isAbstract && !dispatch.defaultVariant) {
+    lines.push(`        throw new ArgumentException("Missing ${typeName} discriminator property: '${dispatch.discriminatorField}'");`);
+  } else if (dispatch.defaultVariant && !dispatch.defaultVariant.isSelfReference) {
+    lines.push(`        throw new ArgumentException("Missing ${typeName} discriminator property: '${dispatch.discriminatorField}'");`);
+  } else {
+    lines.push(`        return new ${typeName}();`);
+  }
+
+  lines.push("");
+  lines.push("    }");
+  lines.push("");
+}
+
+// ============================================================================
+// Save region
+// ============================================================================
+
+function emitSaveRegion(
+  type: TypeDecl,
+  allTypes: TypeDecl[],
+  findType: (name: string) => TypeDecl | undefined,
+  lines: string[],
+): void {
+  lines.push("    #region Save Methods");
+  lines.push("");
+
+  // Main Save method
+  emitSaveMethod(type, allTypes, lines);
+
+  // ToWire method (only when wire mappings exist)
+  if (type.wire) {
+    emitToWireMethod(type, lines);
+  }
+
+  // Collection save helpers
+  for (const helper of type.collectionHelpers) {
+    emitCollectionSaveHelper(helper, lines);
+  }
+
+  // ToYaml, ToJson, FromJson, FromYaml
+  emitSerializationMethods(type, lines);
+
+  lines.push("    #endregion");
+}
+
+function emitSaveMethod(type: TypeDecl, allTypes: TypeDecl[], lines: string[]): void {
+  const typeName = type.typeName.name;
+  const hasBase = type.save.hasBase;
+  const hasChildren = type.polymorphicDispatch !== null || type.isAbstract;
+  // virtual if has children, override if has base
+  let modifier = "";
+  if (hasBase) {
+    modifier = "override ";
+  } else if (hasChildren) {
+    modifier = "virtual ";
+  }
+
+  lines.push("    /// <summary>");
+  lines.push(`    /// Save the ${typeName} instance to a dictionary.`);
+  lines.push("    /// </summary>");
+  lines.push('    /// <param name="context">Optional context with pre/post processing callbacks.</param>');
+  lines.push("    /// <returns>The dictionary representation of this instance.</returns>");
+  lines.push(`    public ${modifier}Dictionary<string, object?> Save(SaveContext? context = null)`);
+  lines.push("    {");
+  lines.push("        var obj = this;");
+  lines.push("        if (context is not null)");
+  lines.push("        {");
+  lines.push("            obj = context.ProcessObject(obj);");
+  lines.push("        }");
+  lines.push("");
+  lines.push("");
+
+  if (hasBase) {
+    lines.push("        // Start with parent class properties");
+    lines.push("        var result = base.Save(context);");
+  } else {
+    lines.push("        var result = new Dictionary<string, object?>();");
+  }
+
+  lines.push("");
+
+  // Per-field saves
+  for (const assign of type.save.assignments) {
+    emitSaveAssignment(assign, lines);
+  }
+
+  // ProcessDict only if no base
+  if (!hasBase) {
+    lines.push("");
+    lines.push("        if (context is not null)");
+    lines.push("        {");
+    lines.push("            result = context.ProcessDict(result);");
+    lines.push("        }");
+  }
+
+  lines.push("");
+  lines.push("        return result;");
+  lines.push("    }");
+  lines.push("");
+}
+
+function emitToWireMethod(type: TypeDecl, lines: string[]): void {
+  const wire = type.wire!;
+
+  lines.push("    /// <summary>");
+  lines.push(`    /// Convert this instance to a provider-specific wire-format dictionary.`);
+  lines.push("    /// </summary>");
+  lines.push('    /// <param name="provider">The provider name (e.g., "openai", "anthropic").</param>');
+  lines.push("    /// <returns>A dictionary with provider-specific field names.</returns>");
+  lines.push("    public Dictionary<string, object?> ToWire(string provider)");
+  lines.push("    {");
+  lines.push("        var data = Save();");
+  lines.push("        var result = new Dictionary<string, object?>();");
+  lines.push("        var wireMap = new Dictionary<string, Dictionary<string, string>>");
+  lines.push("        {");
+
+  for (const mapping of wire.mappings) {
+    const entries = Object.entries(mapping.wireNames);
+    const inner = entries
+      .map(([provider, wireName]) => `["${provider}"] = "${wireName}"`)
+      .join(", ");
+    lines.push(
+      `            ["${mapping.fieldName}"] = new Dictionary<string, string> { ${inner} },`,
+    );
+  }
+
+  lines.push("        };");
+  lines.push("        foreach (var (key, value) in data)");
+  lines.push("        {");
+  lines.push(
+    "            if (wireMap.TryGetValue(key, out var mapping) && mapping.TryGetValue(provider, out var wireName))",
+  );
+  lines.push("                result[wireName] = value;");
+  lines.push("        }");
+  lines.push("        return result;");
+  lines.push("    }");
+  lines.push("");
+}
+
+function emitSaveAssignment(assign: SaveAssignment, lines: string[]): void {
+  const propName = toPascalCase(assign.fieldName);
+  const cat = assign.category;
+
+  lines.push("");
+
+  if (assign.isOptional) {
+    lines.push(`        if (obj.${propName} is not null)`);
+    lines.push("        {");
+    lines.push(`            ${getSaveExpression(assign, propName)}`);
+    lines.push("        }");
+  } else {
+    lines.push(`        ${getSaveExpression(assign, propName)}`);
+  }
+
+  lines.push("");
+}
+
+function getSaveExpression(assign: SaveAssignment, propName: string): string {
+  const cat = assign.category;
+  switch (cat.kind) {
+    case "scalar":
+    case "dict":
+      return `result["${assign.targetName}"] = obj.${propName};`;
+    case "complex":
+      return `result["${assign.targetName}"] = obj.${propName}?.Save(context);`;
+    case "collection_complex":
+      return `result["${assign.targetName}"] = Save${propName}(obj.${propName}, context);`;
+    case "collection_scalar":
+      return `result["${assign.targetName}"] = obj.${propName};`;
+  }
+}
+
+// ============================================================================
+// Collection Save Helper
+// ============================================================================
+
+function emitCollectionSaveHelper(helper: CollectionHelperDecl, lines: string[]): void {
+  const propName = toPascalCase(helper.propertyName);
+  const elemType = helper.elementTypeName.name;
+
+  lines.push("");
+  lines.push("    /// <summary>");
+  lines.push(`    /// Save a list of ${elemType} to object or array format.`);
+  lines.push("    /// </summary>");
+  lines.push(`    public static object Save${propName}(IList<${elemType}> items, SaveContext? context)`);
+  lines.push("    {");
+  lines.push("        context ??= new SaveContext();");
+  lines.push("");
+
+  if (helper.hasNameProperty) {
+    lines.push("");
+    lines.push('        if (context.CollectionFormat == "array")');
+    lines.push("        {");
+    lines.push("            return items.Select(item => item.Save(context)).ToList();");
+    lines.push("        }");
+    lines.push("");
+    lines.push("        // Object format: use name as key");
+    lines.push("        var result = new Dictionary<string, object?>();");
+    lines.push("        foreach (var item in items)");
+    lines.push("        {");
+    lines.push("            var itemData = item.Save(context);");
+    lines.push('            if (itemData.TryGetValue("name", out var nameValue) && nameValue is string name)');
+    lines.push("            {");
+    lines.push('                itemData.Remove("name");');
+    lines.push("");
+    lines.push("                // Check if we can use shorthand");
+    lines.push(`                if (context.UseShorthand && ${elemType}.ShorthandProperty is string shorthandProp)`);
+    lines.push("                {");
+    lines.push("                    if (itemData.Count == 1 && itemData.ContainsKey(shorthandProp))");
+    lines.push("                    {");
+    lines.push("                        result[name] = itemData[shorthandProp];");
+    lines.push("                        continue;");
+    lines.push("                    }");
+    lines.push("                }");
+    lines.push("                result[name] = itemData;");
+    lines.push("            }");
+    lines.push("            else");
+    lines.push("            {");
+    lines.push('                // No name, can\'t use object format for this item');
+    lines.push('                throw new InvalidOperationException("Cannot save item in object format: missing \'name\' property");');
+    lines.push("            }");
+    lines.push("        }");
+    lines.push("        return result;");
+  } else {
+    lines.push("        // This collection type does not have a 'name' property, only array format is supported");
+    lines.push("        return items.Select(item => item.Save(context)).ToList();");
+  }
+
+  lines.push("");
+  lines.push("    }");
+  lines.push("");
+}
+
+// ============================================================================
+// Serialization methods (ToYaml, ToJson, FromJson, FromYaml)
+// ============================================================================
+
+function emitSerializationMethods(type: TypeDecl, lines: string[]): void {
+  const typeName = type.typeName.name;
+  const new_ = type.base ? "new " : "";
+
+  // ToYaml
+  lines.push("");
+  lines.push("    /// <summary>");
+  lines.push(`    /// Convert the ${typeName} instance to a YAML string.`);
+  lines.push("    /// </summary>");
+  lines.push('    /// <param name="context">Optional context with pre/post processing callbacks.</param>');
+  lines.push("    /// <returns>The YAML string representation of this instance.</returns>");
+  lines.push(`    public ${new_}string ToYaml(SaveContext? context = null)`);
+  lines.push("    {");
+  lines.push("        context ??= new SaveContext();");
+  lines.push("        return context.ToYaml(Save(context));");
+  lines.push("    }");
+  lines.push("");
+
+  // ToJson
+  lines.push("    /// <summary>");
+  lines.push(`    /// Convert the ${typeName} instance to a JSON string.`);
+  lines.push("    /// </summary>");
+  lines.push('    /// <param name="context">Optional context with pre/post processing callbacks.</param>');
+  lines.push('    /// <param name="indent">Whether to indent the output. Defaults to true.</param>');
+  lines.push("    /// <returns>The JSON string representation of this instance.</returns>");
+  lines.push(`    public ${new_}string ToJson(SaveContext? context = null, bool indent = true)`);
+  lines.push("    {");
+  lines.push("        context ??= new SaveContext();");
+  lines.push("        return context.ToJson(Save(context), indent);");
+  lines.push("    }");
+  lines.push("");
+
+  // FromJson
+  emitFromJson(type, lines);
+  lines.push("");
+
+  // FromYaml
+  emitFromYaml(type, lines);
+  lines.push("");
+}
+
+// ============================================================================
+// FromJson
+// ============================================================================
+
+function emitFromJson(type: TypeDecl, lines: string[]): void {
+  const typeName = type.typeName.name;
+  const new_ = type.base ? "new " : "";
+  const hasCoercions = type.load.coercions.length > 0;
+  const hasCoercionProp = type.coercionProperty !== null;
+
+  lines.push("    /// <summary>");
+  lines.push(`    /// Load a ${typeName} instance from a JSON string.`);
+  lines.push("    /// </summary>");
+  lines.push('    /// <param name="json">The JSON string to parse.</param>');
+  lines.push('    /// <param name="context">Optional context with pre/post processing callbacks.</param>');
+  lines.push(`    /// <returns>The loaded ${typeName} instance.</returns>`);
+  lines.push(`    public ${new_}static ${typeName} FromJson(string json, LoadContext? context = null)`);
+  lines.push("    {");
+  lines.push("        using var doc = JsonDocument.Parse(json);");
+  lines.push("        Dictionary<string, object?> dict;");
+
+  if (hasCoercions || hasCoercionProp) {
+    lines.push("        // Handle alternate representations");
+    lines.push("        if (doc.RootElement.ValueKind != JsonValueKind.Object)");
+    lines.push("        {");
+    lines.push("            var value = JsonUtils.GetJsonElementValue(doc.RootElement);");
+
+    if (hasCoercions) {
+      lines.push("            dict = value switch");
+      lines.push("            {");
+      emitCoercionSwitchArms(type.load.coercions, type.coercionProperty, "                ", "value", lines);
+      lines.push("            };");
+    } else {
+      // Only coercionProperty, no typed coercions
+      lines.push(`            dict = new Dictionary<string, object?>`);
+      lines.push("            {");
+      lines.push(`                ["${type.coercionProperty}"] = value`);
+      lines.push("            };");
+    }
+
+    lines.push("        }");
+    lines.push("        else");
+    lines.push("        {");
+    lines.push("            dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)");
+    lines.push('                ?? throw new ArgumentException("Failed to parse JSON as dictionary");');
+    lines.push("        }");
+  } else {
+    lines.push("        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)");
+    lines.push('            ?? throw new ArgumentException("Failed to parse JSON as dictionary");');
+  }
+
+  lines.push("");
+  lines.push("        return Load(dict, context);");
+  lines.push("    }");
+}
+
+// ============================================================================
+// FromYaml
+// ============================================================================
+
+function emitFromYaml(type: TypeDecl, lines: string[]): void {
+  const typeName = type.typeName.name;
+  const new_ = type.base ? "new " : "";
+  const hasCoercions = type.load.coercions.length > 0;
+  const hasCoercionProp = type.coercionProperty !== null;
+
+  lines.push("    /// <summary>");
+  lines.push(`    /// Load a ${typeName} instance from a YAML string.`);
+  lines.push("    /// </summary>");
+  lines.push('    /// <param name="yaml">The YAML string to parse.</param>');
+  lines.push('    /// <param name="context">Optional context with pre/post processing callbacks.</param>');
+  lines.push(`    /// <returns>The loaded ${typeName} instance.</returns>`);
+  lines.push(`    public ${new_}static ${typeName} FromYaml(string yaml, LoadContext? context = null)`);
+  lines.push("    {");
+
+  if (hasCoercions || hasCoercionProp) {
+    lines.push("        // Handle alternate representations - try object first, fall back to scalar");
+    lines.push("        Dictionary<string, object?>? dictResult = null;");
+    lines.push("        try");
+    lines.push("        {");
+    lines.push("            dictResult = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml);");
+    lines.push("        }");
+    lines.push("        catch (YamlDotNet.Core.YamlException)");
+    lines.push("        {");
+    lines.push("            // Not a dictionary, will be handled as scalar below");
+    lines.push("        }");
+    lines.push("");
+    lines.push("        Dictionary<string, object?> dict;");
+    lines.push("        if (dictResult is not null)");
+    lines.push("        {");
+    lines.push("            dict = dictResult;");
+    lines.push("        }");
+    lines.push("        else");
+    lines.push("        {");
+    lines.push("            // Parse as scalar with proper type inference");
+    lines.push("            var parsed = YamlUtils.ParseScalar(yaml);");
+
+    if (hasCoercions) {
+      lines.push("            dict = parsed switch");
+      lines.push("            {");
+      emitCoercionSwitchArms(type.load.coercions, type.coercionProperty, "                ", "parsed", lines);
+      lines.push("            };");
+    } else {
+      lines.push(`            dict = new Dictionary<string, object?>`);
+      lines.push("            {");
+      lines.push(`                ["${type.coercionProperty}"] = parsed`);
+      lines.push("            };");
+    }
+
+    lines.push("        }");
+  } else {
+    lines.push("        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)");
+    lines.push('            ?? throw new ArgumentException("Failed to parse YAML as dictionary");');
+  }
+
+  lines.push("");
+  lines.push("        return Load(dict, context);");
+  lines.push("    }");
+}
+
+// ============================================================================
+// Coercion switch arms (shared between FromJson and FromYaml)
+// ============================================================================
+
+function emitCoercionSwitchArms(
+  coercions: CoercionDecl[],
+  coercionProperty: string | null,
+  indent: string,
+  switchVarName: string,
+  lines: string[],
+): void {
+  // Track emitted types to avoid duplicates
+  const emittedTypes = new Set<string>();
+
+  for (const coercion of coercions) {
+    const csharpType = CSHARP_TYPE_MAP[coercion.scalarType] || "object";
+    const varName = `${csharpType}Value`;
+
+    if (emittedTypes.has(csharpType)) continue;
+    emittedTypes.add(csharpType);
+
+    // Emit the main type arm
+    lines.push(`${indent}${csharpType} ${varName} => new Dictionary<string, object?>`);
+    lines.push(`${indent}{`);
+    for (const assign of coercion.assignments) {
+      if (assign.isInput) {
+        lines.push(`${indent}    ["${assign.fieldName}"] = ${varName},`);
+      } else {
+        lines.push(`${indent}    ["${assign.fieldName}"] = "${assign.literalValue}",`);
+      }
+    }
+    lines.push(`${indent}},`);
+
+    // Numeric widening: int → long, float → double
+    if (csharpType === "int" && !emittedTypes.has("long")) {
+      emittedTypes.add("long");
+      lines.push(`${indent}long longValue => new Dictionary<string, object?>`);
+      lines.push(`${indent}{`);
+      for (const assign of coercion.assignments) {
+        if (assign.isInput) {
+          lines.push(`${indent}    ["${assign.fieldName}"] = longValue,`);
+        } else {
+          lines.push(`${indent}    ["${assign.fieldName}"] = "${assign.literalValue}",`);
+        }
+      }
+      lines.push(`${indent}},`);
+    }
+
+    if (csharpType === "float" && !emittedTypes.has("double")) {
+      emittedTypes.add("double");
+      lines.push(`${indent}double doubleValue => new Dictionary<string, object?>`);
+      lines.push(`${indent}{`);
+      for (const assign of coercion.assignments) {
+        if (assign.isInput) {
+          lines.push(`${indent}    ["${assign.fieldName}"] = doubleValue,`);
+        } else {
+          lines.push(`${indent}    ["${assign.fieldName}"] = "${assign.literalValue}",`);
+        }
+      }
+      lines.push(`${indent}},`);
+    }
+  }
+
+  // Default arm
+  if (coercionProperty) {
+    lines.push(`${indent}_ => new Dictionary<string, object?>`);
+    lines.push(`${indent}{`);
+    lines.push(`${indent}    ["${coercionProperty}"] = ${switchVarName}`);
+    lines.push(`${indent}}`);
+  } else {
+    lines.push(`${indent}_ => throw new ArgumentException($"Unsupported scalar type")`);
+  }
+}
+
+// ============================================================================
+// Factory methods
+// ============================================================================
+
+function emitFactoryRegion(type: TypeDecl, visitor: ExprVisitor, lines: string[]): void {
+  lines.push("");
+  lines.push("    #region Factory Methods");
+
+  for (const factory of type.factories) {
+    emitFactoryMethod(factory, type, visitor, lines);
+  }
+
+  lines.push("");
+  lines.push("    #endregion");
+}
+
+function emitFactoryMethod(factory: FactoryDecl, type: TypeDecl, visitor: ExprVisitor, lines: string[]): void {
+  const methodName = getCSharpFactoryMethodName(factory.name, type);
+  const params = Object.entries(factory.params).map(([name, typeStr]) =>
+    `${getCSharpFactoryParamType(typeStr)} ${name}`
+  ).join(", ");
+  const body = visitor.visitExpr(factory.body);
+
+  lines.push("");
+  lines.push("    /// <summary>");
+  lines.push(`    /// Create a ${type.typeName.name} with preset field values.`);
+  lines.push("    /// </summary>");
+  lines.push(`    public static ${type.typeName.name} ${methodName}(${params})`);
+  lines.push("    {");
+  lines.push(`        return ${body};`);
+  lines.push("    }");
+}
+
+function getCSharpFactoryMethodName(factoryName: string, type: TypeDecl): string {
+  const methodName = factoryName.charAt(0).toUpperCase() + factoryName.slice(1);
+  const propertyNames = type.fields.map(f => toPascalCase(f.name));
+  // Also consider @method stubs that emit as properties (zero-param, non-verb names)
+  for (const m of type.methods) {
+    if (!isMethodStyle(m.name) && !m.params?.length) {
+      propertyNames.push(toPascalCase(m.name));
+    }
+  }
+  if (propertyNames.includes(methodName)) {
+    return `Create${methodName}`;
+  }
+  return methodName;
+}
+
+function getCSharpFactoryParamType(typeStr: string): string {
+  switch (typeStr) {
+    case "string": return "string";
+    case "boolean": return "bool";
+    case "integer": case "int32": return "int";
+    case "int64": return "long";
+    case "float": case "float32": return "float";
+    case "float64": return "double";
+    case "unknown": return "object?";
+    default: return "object?";
+  }
+}
+
+// ============================================================================
+// Helper interface (contract for @method declarations)
+// ============================================================================
+
+/**
+ * Verbs that indicate an action — zero-param @methods whose name starts with
+ * one of these get emitted as C# methods. Everything else becomes a read-only
+ * property. This preserves idiomatic C# naming (``message.Text`` is a property,
+ * ``message.ToTextContent()`` is a method).
+ */
+const METHOD_VERB_PREFIXES = [
+  "to", "get", "set", "fetch", "compute", "make", "build", "create",
+  "load", "save", "convert", "parse", "format", "render", "serialize",
+  "deserialize", "find", "calculate", "invoke", "execute", "run",
+];
+
+function isMethodStyle(name: string): boolean {
+  const lower = name.toLowerCase();
+  for (const prefix of METHOD_VERB_PREFIXES) {
+    if (lower === prefix) return true;
+    if (lower.startsWith(prefix) && name.length > prefix.length) {
+      const next = name[prefix.length];
+      if (next === next.toUpperCase() && next !== next.toLowerCase()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Emit a C# interface ``I<TypeName>Helpers`` that declares the @method
+ * contract. The generated partial class declares ``: I<TypeName>Helpers``,
+ * so the C# compiler will error if a hand-written partial does not provide
+ * every contract member. Zero-param queries emit as properties, everything
+ * else as methods.
+ */
+function emitHelperInterface(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+  lines.push("");
+  lines.push("/// <summary>");
+  lines.push(`/// Helper contract for <see cref="${name}"/>.`);
+  lines.push("///");
+  lines.push(`/// Runtime implementations must provide these members on ${name} (via a`);
+  lines.push(`/// hand-written partial class). The C# compiler enforces conformance`);
+  lines.push(`/// because ${name} declares : I${name}Helpers.`);
+  lines.push("/// </summary>");
+  lines.push(`public partial interface I${name}Helpers`);
+  lines.push("{");
+  for (const m of type.methods) {
+    const pascalName = toPascalCase(m.name);
+    const ret = protocolCSharpType(m.returns);
+    if (m.description) {
+      emitXmlDocComment(m.description, "    ", lines);
+    }
+    const paramEntries = Object.entries(m.params);
+    if (paramEntries.length === 0 && !isMethodStyle(m.name)) {
+      // Property-style: ``T Foo { get; }``
+      lines.push(`    ${ret} ${pascalName} { get; }`);
+    } else {
+      const params = paramEntries
+        .map(([pName, pType]) => `${protocolCSharpType(pType)} ${pName}`)
+        .join(", ");
+      lines.push(`    ${ret} ${pascalName}(${params});`);
+    }
+  }
+  lines.push("}");
+}
+
+function emitHelperRegion(type: TypeDecl, lines: string[]): void {
+  // Intentionally empty — the body of the partial class no longer contains
+  // comments about helpers. The contract is expressed via the sibling
+  // I<TypeName>Helpers interface emitted after the class.
+  void type;
+  void lines;
+}
diff --git a/schema/emitter/src/templates/csharp/utils.cs.njk b/schema/emitter/src/languages/csharp/scaffolding.ts
similarity index 71%
rename from schema/emitter/src/templates/csharp/utils.cs.njk
rename to schema/emitter/src/languages/csharp/scaffolding.ts
index e6443712..2e02605a 100644
--- a/schema/emitter/src/templates/csharp/utils.cs.njk
+++ b/schema/emitter/src/languages/csharp/scaffolding.ts
@@ -1,4 +1,179 @@
-// Copyright (c) Microsoft. All rights reserved.
+/**
+ * C# scaffolding emitter — static support files.
+ *
+ * Replaces `context.cs.njk` and `utils.cs.njk` Nunjucks templates with typed
+ * TypeScript functions that produce the same C# source code.
+ *
+ * Emitted files:
+ *   - Context.cs  — LoadContext / SaveContext helper classes
+ *   - Utils.cs    — JsonUtils, YamlUtils, and internal Utils extension methods
+ */
+
+// ============================================================================
+// Context.cs
+// ============================================================================
+
+/**
+ * Emit the C# LoadContext / SaveContext file.
+ */
+export function emitCSharpContext(namespace: string): string {
+  return `// Copyright (c) Microsoft. All rights reserved.
+using System.Text.Json;
+using YamlDotNet.Serialization;
+
+#pragma warning disable IDE0130
+namespace ${namespace};
+#pragma warning restore IDE0130
+
+/// <summary>
+/// Context for customizing the loading process of agent definitions.
+/// Provides hooks for pre-processing input data before parsing and
+/// post-processing output data after instantiation.
+/// </summary>
+public class LoadContext
+{
+    /// <summary>
+    /// Optional callback to transform input data before parsing.
+    /// </summary>
+    public Func<Dictionary<string, object?>, Dictionary<string, object?>>? PreProcess { get; set; }
+
+    /// <summary>
+    /// Optional callback to transform the result after instantiation.
+    /// </summary>
+    public Func<object, object>? PostProcess { get; set; }
+
+    /// <summary>
+    /// Apply pre-processing to input data if a PreProcess callback is set.
+    /// </summary>
+    /// <param name="data">The raw input dictionary to process.</param>
+    /// <returns>The processed dictionary, or the original if no callback is set.</returns>
+    public Dictionary<string, object?> ProcessInput(Dictionary<string, object?> data)
+    {
+        if (PreProcess is not null)
+        {
+            return PreProcess(data);
+        }
+        return data;
+    }
+
+    /// <summary>
+    /// Apply post-processing to the result if a PostProcess callback is set.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The instantiated object to process.</param>
+    /// <returns>The processed result, or the original if no callback is set.</returns>
+    public T ProcessOutput<T>(T result) where T : class
+    {
+        if (PostProcess is not null)
+        {
+            return (T)PostProcess(result);
+        }
+        return result;
+    }
+}
+
+/// <summary>
+/// Context for customizing the serialization process of agent definitions.
+/// Provides hooks for pre-processing the object before serialization and
+/// post-processing the dictionary after serialization.
+/// </summary>
+public class SaveContext
+{
+    /// <summary>
+    /// Optional callback to transform the object before serialization.
+    /// </summary>
+    public Func<object, object>? PreSave { get; set; }
+
+    /// <summary>
+    /// Optional callback to transform the dictionary after serialization.
+    /// </summary>
+    public Func<Dictionary<string, object?>, Dictionary<string, object?>>? PostSave { get; set; }
+
+    /// <summary>
+    /// Output format for collections: "object" (name as key) or "array" (list of dicts).
+    /// Defaults to "object".
+    /// </summary>
+    public string CollectionFormat { get; set; } = "object";
+
+    /// <summary>
+    /// Use shorthand scalar representation when possible (e.g., {"myTool": "function"}).
+    /// Defaults to true.
+    /// </summary>
+    public bool UseShorthand { get; set; } = true;
+
+    /// <summary>
+    /// Apply pre-processing to the object if a PreSave callback is set.
+    /// </summary>
+    /// <typeparam name="T">The type of the object.</typeparam>
+    /// <param name="obj">The object to process before serialization.</param>
+    /// <returns>The processed object, or the original if no callback is set.</returns>
+    public T ProcessObject<T>(T obj) where T : class
+    {
+        if (PreSave is not null)
+        {
+            return (T)PreSave(obj);
+        }
+        return obj;
+    }
+
+    /// <summary>
+    /// Apply post-processing to the dictionary if a PostSave callback is set.
+    /// </summary>
+    /// <param name="data">The serialized dictionary to process.</param>
+    /// <returns>The processed dictionary, or the original if no callback is set.</returns>
+    public Dictionary<string, object?> ProcessDict(Dictionary<string, object?> data)
+    {
+        if (PostSave is not null)
+        {
+            return PostSave(data);
+        }
+        return data;
+    }
+
+    private static readonly JsonSerializerOptions s_jsonOptions = new()
+    {
+        WriteIndented = true,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+    };
+
+    private static readonly ISerializer s_yamlSerializer = new SerializerBuilder()
+        .ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull)
+        .Build();
+
+    /// <summary>
+    /// Convert the dictionary to a YAML string.
+    /// </summary>
+    /// <param name="data">The dictionary to convert.</param>
+    /// <returns>The YAML string representation.</returns>
+    public string ToYaml(Dictionary<string, object?> data)
+    {
+        return s_yamlSerializer.Serialize(data);
+    }
+
+    /// <summary>
+    /// Convert the dictionary to a JSON string.
+    /// </summary>
+    /// <param name="data">The dictionary to convert.</param>
+    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
+    /// <returns>The JSON string representation.</returns>
+    public string ToJson(Dictionary<string, object?> data, bool indent = true)
+    {
+        var options = indent ? s_jsonOptions : new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
+        return JsonSerializer.Serialize(data, options);
+    }
+}
+`;
+}
+
+// ============================================================================
+// Utils.cs
+// ============================================================================
+
+/**
+ * Emit the C# utility classes file (JsonUtils, YamlUtils, Utils).
+ */
+export function emitCSharpUtils(namespace: string): string {
+  return `// Copyright (c) Microsoft. All rights reserved.
 using System.Collections;
 using System.Reflection;
 using System.Text.Json;
@@ -7,7 +182,7 @@ using YamlDotNet.Serialization;
 using YamlDotNet.Serialization.NamingConventions;
 
 #pragma warning disable IDE0130
-namespace {{ namespace }};
+namespace ${namespace};
 #pragma warning restore IDE0130
 
 /// <summary>
@@ -415,3 +590,5 @@ internal static class Utils
         return dict;
     }
 }
+`;
+}
diff --git a/schema/emitter/src/languages/csharp/test-emitter.ts b/schema/emitter/src/languages/csharp/test-emitter.ts
new file mode 100644
index 00000000..9b807644
--- /dev/null
+++ b/schema/emitter/src/languages/csharp/test-emitter.ts
@@ -0,0 +1,302 @@
+/**
+ * C# test emitter — TypeNode → xUnit test file.
+ *
+ * Replaces `test.cs.njk` Nunjucks template with a typed TypeScript function
+ * that produces a complete C# xUnit test class.
+ *
+ * Each TypeNode with samples/coercions/factories gets one test file
+ * containing LoadYaml, LoadJson, roundtrip, and validity tests.
+ */
+
+import { FactoryEntry } from "../../decorators.js";
+import { TypeNode } from "../../ir/ast.js";
+
+// ============================================================================
+// Public types
+// ============================================================================
+
+export interface CSharpTestContext {
+  node: TypeNode;
+  namespace: string;
+  examples: Array<{
+    json: string[];
+    yaml: string[];
+    validations: Array<{ key: string; value: any; startDelim: string; endDelim: string }>;
+  }>;
+  coercions: Array<{
+    title: string;
+    scalar: string;
+    value: string | number;
+    validations: Array<{ key: string; value: any; delimiter: string }>;
+  }>;
+  factories: FactoryEntry[];
+  renderName: (name: string) => string;
+  renderCsharpFactoryMethodName: (factoryName: string) => string;
+  renderCsharpFactoryTestValue: (typeStr: string) => string;
+}
+
+// ============================================================================
+// Main entry point
+// ============================================================================
+
+/**
+ * Emit a complete C# xUnit test file for a type node.
+ */
+export function emitCSharpTest(ctx: CSharpTestContext): string {
+  const typeName = ctx.node.typeName.name;
+  const L: string[] = [];
+
+  L.push('using Xunit;');
+  L.push('');
+  L.push('#pragma warning disable IDE0130');
+  L.push(`namespace ${ctx.namespace};`);
+  L.push('#pragma warning restore IDE0130');
+  L.push('');
+  L.push('');
+  L.push(`public class ${typeName}ConversionTests`);
+  L.push('{');
+
+  // --- Example tests (6 per example) ---
+  ctx.examples.forEach((sample, i) => {
+    const suffix = i === 0 ? '' : `${i}`;
+
+    // LoadYamlInput
+    L.push('    [Fact]');
+    L.push(`    public void LoadYamlInput${suffix}()`);
+    L.push('    {');
+    L.push(...emitRawStringLiteral('yamlData', sample.yaml));
+    L.push('');
+    L.push(`        var instance = ${typeName}.FromYaml(yamlData);`);
+    L.push('');
+    L.push('        Assert.NotNull(instance);');
+    const yamlAssertions = emitExampleAssertions(sample.validations, 'instance');
+    if (yamlAssertions) L.push(yamlAssertions);
+    L.push('    }');
+    L.push('');
+
+    // LoadJsonInput
+    L.push('    [Fact]');
+    L.push(`    public void LoadJsonInput${suffix}()`);
+    L.push('    {');
+    L.push(...emitRawStringLiteral('jsonData', sample.json));
+    L.push('');
+    L.push(`        var instance = ${typeName}.FromJson(jsonData);`);
+    L.push('        Assert.NotNull(instance);');
+    const jsonAssertions = emitExampleAssertions(sample.validations, 'instance');
+    if (jsonAssertions) L.push(jsonAssertions);
+    L.push('    }');
+    L.push('');
+
+    // RoundtripJson
+    L.push('    [Fact]');
+    L.push(`    public void RoundtripJson${suffix}()`);
+    L.push('    {');
+    L.push('        // Test that FromJson -> ToJson -> FromJson produces equivalent data');
+    L.push(...emitRawStringLiteral('jsonData', sample.json));
+    L.push('');
+    L.push(`        var original = ${typeName}.FromJson(jsonData);`);
+    L.push('        Assert.NotNull(original);');
+    L.push('');
+    L.push('        var json = original.ToJson();');
+    L.push('        Assert.False(string.IsNullOrEmpty(json));');
+    L.push('');
+    L.push(`        var reloaded = ${typeName}.FromJson(json);`);
+    L.push('        Assert.NotNull(reloaded);');
+    const rtJsonAssertions = emitExampleAssertions(sample.validations, 'reloaded');
+    if (rtJsonAssertions) L.push(rtJsonAssertions);
+    L.push('    }');
+    L.push('');
+
+    // RoundtripYaml
+    L.push('    [Fact]');
+    L.push(`    public void RoundtripYaml${suffix}()`);
+    L.push('    {');
+    L.push('        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data');
+    L.push(...emitRawStringLiteral('yamlData', sample.yaml));
+    L.push('');
+    L.push(`        var original = ${typeName}.FromYaml(yamlData);`);
+    L.push('        Assert.NotNull(original);');
+    L.push('');
+    L.push('        var yaml = original.ToYaml();');
+    L.push('        Assert.False(string.IsNullOrEmpty(yaml));');
+    L.push('');
+    L.push(`        var reloaded = ${typeName}.FromYaml(yaml);`);
+    L.push('        Assert.NotNull(reloaded);');
+    const rtYamlAssertions = emitExampleAssertions(sample.validations, 'reloaded');
+    if (rtYamlAssertions) L.push(rtYamlAssertions);
+    L.push('    }');
+    L.push('');
+
+    // ToJsonProducesValidJson
+    L.push('    [Fact]');
+    L.push(`    public void ToJsonProducesValidJson${suffix}()`);
+    L.push('    {');
+    L.push(...emitRawStringLiteral('jsonData', sample.json));
+    L.push('');
+    L.push(`        var instance = ${typeName}.FromJson(jsonData);`);
+    L.push('        var json = instance.ToJson();');
+    L.push('');
+    L.push('        // Verify it\'s valid JSON by parsing it');
+    L.push('        var parsed = System.Text.Json.JsonDocument.Parse(json);');
+    L.push('        Assert.NotNull(parsed);');
+    L.push('    }');
+    L.push('');
+
+    // ToYamlProducesValidYaml
+    L.push('    [Fact]');
+    L.push(`    public void ToYamlProducesValidYaml${suffix}()`);
+    L.push('    {');
+    L.push(...emitRawStringLiteral('yamlData', sample.yaml));
+    L.push('');
+    L.push(`        var instance = ${typeName}.FromYaml(yamlData);`);
+    L.push('        var yaml = instance.ToYaml();');
+    L.push('');
+    L.push('        // Verify it\'s valid YAML by parsing it');
+    L.push('        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();');
+    L.push('        var parsed = deserializer.Deserialize<object>(yaml);');
+    L.push('        Assert.NotNull(parsed);');
+    L.push('    }');
+  });
+
+  // --- Coercion tests (2 per coercion) ---
+  if (ctx.coercions.length > 0) {
+    for (const alt of ctx.coercions) {
+      const titleScalar = alt.scalar.charAt(0).toUpperCase() + alt.scalar.slice(1);
+
+      // Build the C# data literal
+      let dataLine: string;
+      if (alt.scalar === 'string') {
+        dataLine = `        var data = "${alt.value.toString().replace(/\\/g, '\\\\').replace(/"/g, '\\"')}";`;
+      } else {
+        let dataValue: string;
+        if (alt.value.toString() === "True") dataValue = "true";
+        else if (alt.value.toString() === "False") dataValue = "false";
+        else dataValue = alt.value.toString();
+        dataLine = `        var data = "${dataValue}";`;
+      }
+
+      // LoadJsonFrom{Scalar}
+      L.push('');
+      L.push('    [Fact]');
+      L.push(`    public void LoadJsonFrom${titleScalar}()`);
+      L.push('    {');
+      L.push(`        // alternate representation as ${alt.scalar}`);
+      L.push(dataLine);
+      L.push(`        var instance = ${typeName}.FromJson(data);`);
+      L.push('        Assert.NotNull(instance);');
+      const jsonCoercionAssertions = emitCoercionAssertions(alt.validations);
+      if (jsonCoercionAssertions) L.push(jsonCoercionAssertions);
+      L.push('    }');
+
+      // LoadYamlFrom{Scalar}
+      L.push('');
+      L.push('    [Fact]');
+      L.push(`    public void LoadYamlFrom${titleScalar}()`);
+      L.push('    {');
+      L.push(`        // alternate representation as ${alt.scalar}`);
+      L.push(dataLine);
+      L.push(`        var instance = ${typeName}.FromYaml(data);`);
+      L.push('        Assert.NotNull(instance);');
+      L.push('');
+      const yamlCoercionAssertions = emitCoercionAssertions(alt.validations);
+      if (yamlCoercionAssertions) L.push(yamlCoercionAssertions);
+      L.push('    }');
+    }
+  }
+
+  // --- Factory tests (1 per factory) ---
+  if (ctx.factories.length > 0) {
+    for (const factory of ctx.factories) {
+      const methodName = ctx.renderCsharpFactoryMethodName(factory.name);
+      const paramValues = Object.values(factory.params)
+        .map(pType => ctx.renderCsharpFactoryTestValue(pType))
+        .join(', ');
+
+      L.push('');
+      L.push('    [Fact]');
+      L.push(`    public void Factory${methodName}()`);
+      L.push('    {');
+      L.push(`        var instance = ${typeName}.${methodName}(${paramValues});`);
+      L.push('        Assert.NotNull(instance);');
+
+      for (const [propName, value] of Object.entries(factory.sets)) {
+        if (value === true) {
+          L.push(`        Assert.True(instance.${ctx.renderName(propName)});`);
+        } else if (value === false) {
+          L.push(`        Assert.False(instance.${ctx.renderName(propName)});`);
+        } else if (typeof value === 'number') {
+          L.push(`        Assert.Equal(${value}, instance.${ctx.renderName(propName)});`);
+        } else if (typeof value === 'string') {
+          L.push(`        Assert.Equal("${value}", instance.${ctx.renderName(propName)});`);
+        }
+      }
+
+      L.push('    }');
+    }
+  }
+
+  L.push('}');
+  L.push('');
+
+  return L.join('\n');
+}
+
+// ============================================================================
+// Assertion helpers
+// ============================================================================
+
+/** Render Assert.Equal / Assert.True / Assert.False lines for example validations. */
+function emitExampleAssertions(
+  validations: Array<{ key: string; value: any; startDelim: string; endDelim: string }>,
+  varName: string,
+): string {
+  return validations.map(v => {
+    if (v.value === "True" || v.value === "False") {
+      return `        Assert.${v.value === "False" ? "False" : "True"}(${varName}.${v.key});`;
+    }
+    if (v.startDelim === '@"') {
+      return `        Assert.Equal(${v.startDelim}${v.value}${v.endDelim}.Replace("\\r\\n", "\\n"), ${varName}.${v.key});`;
+    }
+    return `        Assert.Equal(${v.startDelim}${v.value}${v.endDelim}, ${varName}.${v.key});`;
+  }).join('\n');
+}
+
+/** Render assertion lines for coercion validations (with isFloat / bool / normal dispatch). */
+function emitCoercionAssertions(
+  validations: Array<{ key: string; value: any; delimiter: string }>,
+): string {
+  return validations.map(v => {
+    const valueStr = v.value.toString();
+    if (valueStr === "True" || valueStr === "False") {
+      return [
+        `        Assert.NotNull(instance.${v.key});`,
+        `        Assert.IsType<bool>(instance.${v.key});`,
+        `        Assert.${valueStr === "False" ? "False" : "True"}((bool)instance.${v.key});`,
+      ].join('\n');
+    }
+    // isFloat: value string contains '.'
+    if (valueStr.includes('.')) {
+      return [
+        `        Assert.NotNull(instance.${v.key});`,
+        `        Assert.True(instance.${v.key} is float || instance.${v.key} is double || instance.${v.key} is int || instance.${v.key} is long);`,
+        `        Assert.Equal(${v.value}, Convert.ToDouble(instance.${v.key}), 5);`,
+      ].join('\n');
+    }
+    return `        Assert.Equal(${v.delimiter}${v.value}${v.delimiter}, instance.${v.key});`;
+  }).join('\n');
+}
+
+// ============================================================================
+// Raw string literal helper
+// ============================================================================
+
+/** Emit a raw-string-literal block for C# (lines at column 0, delimiters on own lines). */
+function emitRawStringLiteral(varName: string, dataLines: string[]): string[] {
+  const lines: string[] = [];
+  lines.push(`        string ${varName} = """`);
+  for (const line of dataLines) {
+    lines.push(line);
+  }
+  lines.push('""";');
+  return lines;
+}
diff --git a/schema/emitter/src/languages/csharp/visitor.ts b/schema/emitter/src/languages/csharp/visitor.ts
new file mode 100644
index 00000000..9b363900
--- /dev/null
+++ b/schema/emitter/src/languages/csharp/visitor.ts
@@ -0,0 +1,78 @@
+/**
+ * C# expression visitor — Expr IR → C# source fragments.
+ */
+
+import { Expr, Construct, VariantConstruct, ArrayLiteral, TypeRegistry } from "../../ir/expansion.js";
+import { ExprVisitor, toPascalCase, assertNever } from "../../ir/visitor.js";
+
+export class CSharpExprVisitor implements ExprVisitor {
+  registry?: TypeRegistry;
+
+  constructor(registry?: TypeRegistry) {
+    this.registry = registry;
+  }
+
+  visitExpr(expr: Expr): string {
+    switch (expr.kind) {
+      case "string":
+        return `"${this.escapeString(expr.value)}"`;
+      case "number":
+        return String(expr.value);
+      case "boolean":
+        return expr.value ? "true" : "false";
+      case "null":
+        return "null";
+      case "param":
+        return expr.name;
+      case "construct":
+        return this.visitConstruct(expr);
+      case "variant":
+        return this.visitVariant(expr);
+      case "array":
+        return this.visitArray(expr);
+      case "dict":
+        return `new Dictionary<string, object?> { ${expr.entries.map(e => `{ "${e.key}", ${this.visitExpr(e.value)} }`).join(", ")} }`;
+      case "field_read":
+        return `${expr.objectName}.${toPascalCase(expr.fieldName)}`;
+      default:
+        return assertNever(expr);
+    }
+  }
+
+  private visitConstruct(expr: Construct): string {
+    const typeName = expr.typeName.name;
+    if (expr.fields.length === 0) {
+      return `new ${typeName}()`;
+    }
+    // C# uses object initializer syntax: new Type { Prop = value }
+    const fields = expr.fields.map(f =>
+      `${toPascalCase(f.propertyName)} = ${this.visitExpr(f.value)}`
+    ).join(", ");
+    return `new ${typeName} { ${fields} }`;
+  }
+
+  private visitVariant(expr: VariantConstruct): string {
+    // In C#, polymorphic children are full classes
+    const variantName = expr.variantTypeName.name;
+    if (expr.fields.length === 0) {
+      return `new ${variantName}()`;
+    }
+    const fields = expr.fields.map(f =>
+      `${toPascalCase(f.propertyName)} = ${this.visitExpr(f.value)}`
+    ).join(", ");
+    return `new ${variantName} { ${fields} }`;
+  }
+
+  private visitArray(expr: ArrayLiteral): string {
+    const elementType = expr.elementTypeName.name;
+    if (expr.items.length === 0) {
+      return `new List<${elementType}>()`;
+    }
+    const items = expr.items.map(i => this.visitExpr(i)).join(", ");
+    return `new List<${elementType}> { ${items} }`;
+  }
+
+  private escapeString(s: string): string {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+}
diff --git a/schema/emitter/src/languages/go/driver.ts b/schema/emitter/src/languages/go/driver.ts
new file mode 100644
index 00000000..d85cc293
--- /dev/null
+++ b/schema/emitter/src/languages/go/driver.ts
@@ -0,0 +1,160 @@
+import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
+import { execFileSync } from "child_process";
+import { resolve } from "path";
+import { EmitTarget, PromptyEmitterOptions } from "../../lib.js";
+import {
+  BaseTestContext,
+  enumerateTypes,
+  TypeNode,
+} from "../../ir/ast.js";
+import { GeneratorOptions, filterNodes } from "../../emitter.js";
+
+import { buildBaseTestContext, goTestOptions } from "../../testing/test-context.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+import { TypeRegistry } from "../../ir/expansion.js";
+import { GoExprVisitor } from "./visitor.js";
+import { lowerFile, collectPolymorphicTypeNames } from "../../ir/lower.js";
+import { emitGoFileContent } from "./emitter.js";
+import { emitGoContext } from "./scaffolding.js";
+import { emitGoTest } from "./test-emitter.js";
+
+
+/**
+ * Type mapping from TypeSpec scalar types to Go types.
+ */
+export const goTypeMapper: Record<string, string> = {
+  "string": "string",
+  "number": "float64",
+  "array": "[]",
+  "object": "map[string]interface{}",
+  "boolean": "bool",
+  "int64": "int64",
+  "int32": "int32",
+  "float64": "float64",
+  "float32": "float32",
+  "integer": "int",
+  "float": "float64",
+  "numeric": "float64",
+  "any": "interface{}",
+  "dictionary": "map[string]interface{}",
+};
+
+
+/**
+ * Main entry point for Go code generation.
+ */
+export const generateGo = async (
+  context: EmitContext<PromptyEmitterOptions>,
+  node: TypeNode,
+  emitTarget: EmitTarget,
+  options?: GeneratorOptions
+): Promise<void> => {
+  const allTypes = Array.from(enumerateTypes(node));
+  const nodes = filterNodes(allTypes, options);
+
+  // Build the expression IR infrastructure
+  const registry = TypeRegistry.fromTypeGraph(allTypes);
+  const visitor = new GoExprVisitor(registry);
+
+  // Determine package name from root node namespace (e.g., "Prompty" -> "prompty")
+  const packageName = node.typeName.namespace.toLowerCase().replace(/\./g, '');
+
+  // Collect all polymorphic type names across all nodes
+  const polymorphicTypeNames = new Set<string>();
+  for (const n of nodes) {
+    const polyTypes = n.retrievePolymorphicTypes();
+    if (polyTypes) {
+      polymorphicTypeNames.add(n.typeName.name);
+    }
+  }
+
+  // Emit context file (LoadContext/SaveContext utilities)
+  const contextContent = emitGoContext({ header: "Prompty Context", packageName });
+  await emitGoFile(context, 'context.go', contextContent, emitTarget["output-dir"]);
+
+  // Emit each base type and its children as a single file
+  for (const n of nodes) {
+    // Skip child types - they're rendered with their parent
+    if (!n.base) {
+      const fileDecl = lowerFile(n, registry, polymorphicTypeNames);
+      const fileContent = emitGoFileContent(fileDecl.types, packageName, visitor, polymorphicTypeNames);
+      const fileName = toSnakeCase(n.typeName.name) + '.go';
+      await emitGoFile(context, fileName, fileContent, emitTarget["output-dir"]);
+    }
+
+    // Emit test file for each type (skip protocols — they have no data to test)
+    if (emitTarget["test-dir"] && !n.isProtocol) {
+      const importPath = emitTarget["import-path"] || packageName;
+      const testContext = { ...buildTestContext(n, packageName), importPath };
+      const testContent = emitGoTest(testContext);
+      const testFileName = toSnakeCase(n.typeName.name) + '_test.go';
+      await emitGoFile(context, testFileName, testContent, emitTarget["test-dir"]);
+    }
+  }
+
+  // Format emitted files if format option is enabled (default: true)
+  if (emitTarget.format !== false) {
+    const outputDir = emitTarget["output-dir"]
+      ? resolve(process.cwd(), emitTarget["output-dir"])
+      : context.emitterOutputDir;
+    const testDir = emitTarget["test-dir"]
+      ? resolve(process.cwd(), emitTarget["test-dir"])
+      : undefined;
+
+    formatGoFiles(outputDir, testDir);
+  }
+};
+
+/**
+ * Format Go files using gofmt and goimports.
+ */
+function formatGoFiles(outputDir: string, testDir?: string): void {
+  const dirs = [outputDir, ...(testDir ? [testDir] : [])];
+
+  for (const dir of dirs) {
+    // Run gofmt — use execFileSync to avoid shell injection
+    try {
+      execFileSync("gofmt", ["-w", dir], {
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      });
+    } catch (error) {
+      console.warn(`Warning: gofmt formatting failed for ${dir}. You may need to install Go.`);
+    }
+
+    // Run goimports if available
+    try {
+      execFileSync("goimports", ["-w", dir], {
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      });
+    } catch (error) {
+      // goimports is optional, don't warn if not available
+    }
+  }
+}
+
+/**
+ * Build context for rendering a test file.
+ */
+function buildTestContext(node: TypeNode, packageName: string): BaseTestContext {
+  return buildBaseTestContext(node, packageName, goTestOptions);
+}
+
+/**
+ * Write generated Go content to file.
+ */
+async function emitGoFile(
+  context: EmitContext<PromptyEmitterOptions>,
+  filename: string,
+  content: string,
+  outputDir?: string
+): Promise<void> {
+  outputDir = outputDir || `${context.emitterOutputDir}/go`;
+  const filePath = resolvePath(outputDir, filename);
+
+  await emitFile(context.program, {
+    path: filePath,
+    content,
+  });
+}
diff --git a/schema/emitter/src/languages/go/emitter.ts b/schema/emitter/src/languages/go/emitter.ts
new file mode 100644
index 00000000..2ce28769
--- /dev/null
+++ b/schema/emitter/src/languages/go/emitter.ts
@@ -0,0 +1,1068 @@
+/**
+ * Go code emitter — Declaration IR → Go source code.
+ *
+ * Replaces `file.go.njk` Nunjucks template with a typed TypeScript function
+ * that walks the TypeDecl tree and produces a complete Go source file.
+ *
+ * Each file contains one type hierarchy (parent + children).
+ * Go has no inheritance — child structs duplicate parent fields.
+ * Polymorphic types use interface{} and type switches.
+ *
+ * Structural blocks emitted per type (in order):
+ *   1. Description comment
+ *   2. Struct definition
+ *   3. Load function
+ *   4. Save method
+ *   5. ToJSON method
+ *   6. ToYAML method
+ *   7. FromJSON function
+ *   8. FromYAML function
+ */
+
+import {
+  TypeDecl,
+  FieldDecl,
+  LoadAssignment,
+  SaveAssignment,
+  PolymorphicDispatchDecl,
+  CoercionDecl,
+  CoercionAssignment,
+  PropertyCategory,
+  FactoryDecl,
+  MethodStubDecl,
+  WireDecl,
+} from "../../ir/declarations.js";
+import { ExprVisitor, toPascalCase } from "../../ir/visitor.js";
+
+// ============================================================================
+// Type maps
+// ============================================================================
+
+const GO_TYPE_MAP: Record<string, string> = {
+  string: "string",
+  number: "float64",
+  boolean: "bool",
+  int64: "int64",
+  int32: "int32",
+  float64: "float64",
+  float32: "float32",
+  integer: "int",
+  float: "float64",
+  numeric: "float64",
+  any: "interface{}",
+  unknown: "interface{}",
+  dictionary: "map[string]interface{}",
+};
+
+/** Go types that need numeric type-switch coercion in Load. */
+const NUMERIC_GO_TYPES = new Set(["int", "int32", "int64", "float32", "float64"]);
+
+/** Float Go types get an identity case (v = n) in the type switch. */
+const FLOAT_GO_TYPES = new Set(["float32", "float64"]);
+
+// ============================================================================
+// Main entry point
+// ============================================================================
+
+/**
+ * Emit a complete Go source file for a type hierarchy.
+ *
+ * @param types - All TypeDecls in this file (parent first, then children)
+ * @param packageName - Go package name (lowercase)
+ * @param visitor - Expression visitor for coercion rendering
+ * @param polymorphicTypeNames - Set of type names that are polymorphic bases
+ */
+export function emitGoFileContent(
+  types: TypeDecl[],
+  packageName: string,
+  visitor: ExprVisitor,
+  polymorphicTypeNames: Set<string>,
+): string {
+  const lines: string[] = [];
+
+  // Protocol-only files have a simpler header (no JSON/YAML imports)
+  const hasNonProtocol = types.some(t => !t.isProtocol);
+  if (hasNonProtocol) {
+    emitHeader(lines, packageName);
+  } else {
+    emitProtocolHeader(lines, packageName);
+  }
+
+  // Emit each type in the hierarchy
+  for (const type of types) {
+    emitTypeBlock(type, lines, visitor, polymorphicTypeNames);
+  }
+
+  return lines.join("\n");
+}
+
+// ============================================================================
+// File header
+// ============================================================================
+
+function emitHeader(lines: string[], packageName: string): void {
+  lines.push("// Code generated by AgentSchema emitter; DO NOT EDIT.");
+  lines.push("");
+  lines.push(`package ${packageName}`);
+  lines.push("");
+  lines.push("import (");
+  lines.push('\t"encoding/json"');
+  lines.push("");
+  lines.push('\t"gopkg.in/yaml.v3"');
+  lines.push(")");
+  lines.push("");
+}
+
+function emitProtocolHeader(lines: string[], packageName: string): void {
+  lines.push("// Code generated by AgentSchema emitter; DO NOT EDIT.");
+  lines.push("");
+  lines.push(`package ${packageName}`);
+  lines.push("");
+}
+
+// ============================================================================
+// Type block — one complete type definition
+// ============================================================================
+
+function emitTypeBlock(
+  type: TypeDecl,
+  lines: string[],
+  visitor: ExprVisitor,
+  polymorphicTypeNames: Set<string>,
+): void {
+  const typeName = type.typeName.name;
+
+  // Protocol types → emit as Go interface
+  if (type.isProtocol) {
+    emitProtocolInterface(type, lines);
+    return;
+  }
+
+  const isPolymorphicBase = type.polymorphicDispatch !== null;
+
+  // Description comment
+  emitDescriptionComment(typeName, type.description, lines);
+
+  // Struct definition
+  emitStruct(type, lines, polymorphicTypeNames);
+
+  // Load function
+  emitLoadFunction(type, lines, polymorphicTypeNames);
+
+  // Save method
+  emitSaveMethod(type, lines, polymorphicTypeNames);
+
+  // ToWire method (only when wire mappings exist)
+  if (type.wire) {
+    emitToWireMethod(type, lines);
+  }
+
+  // ToJSON method
+  emitToJSON(typeName, lines);
+
+  // ToYAML method
+  emitToYAML(typeName, lines);
+
+  // FromJSON function
+  emitFromJSON(typeName, isPolymorphicBase, lines);
+
+  // FromYAML function
+  emitFromYAML(typeName, isPolymorphicBase, lines);
+
+  // Factory functions
+  if (type.factories.length > 0) {
+    for (const factory of type.factories) {
+      emitFactoryFunction(typeName, factory, visitor, lines);
+    }
+  }
+
+  // Method stubs
+  if (type.methods.length > 0) {
+    emitMethodStubs(typeName, type.methods, lines);
+  }
+}
+
+// ============================================================================
+// Description comment
+// ============================================================================
+
+function emitDescriptionComment(typeName: string, description: string, lines: string[]): void {
+  if (!description) {
+    lines.push(`// ${typeName} represents a schema type`);
+    return;
+  }
+
+  const descLines = description.split(/\r?\n/);
+  const firstLine = descLines[0];
+  lines.push(`// ${typeName} represents ${firstLine}`);
+
+  for (let i = 1; i < descLines.length; i++) {
+    const line = descLines[i];
+    if (line.trim() === "") {
+      lines.push("//");
+    } else {
+      lines.push(`// ${line}`);
+    }
+  }
+
+  // Blank line after description (unless it's "a schema type")
+  if (description !== "a schema type") {
+    lines.push("");
+  }
+}
+
+// ============================================================================
+// Struct definition
+// ============================================================================
+
+function emitStruct(
+  type: TypeDecl,
+  lines: string[],
+  polymorphicTypeNames: Set<string>,
+): void {
+  const typeName = type.typeName.name;
+  lines.push(`type ${typeName} struct {`);
+
+  for (const field of type.fields) {
+    const goType = getGoFieldType(field.category, field.isOptional, polymorphicTypeNames);
+    const fieldName = toPascalCase(field.name);
+    const tag = getStructTag(field.name, field.isOptional);
+    lines.push(`\t${fieldName} ${goType} ${tag}`);
+  }
+
+  lines.push("}");
+  lines.push("");
+}
+
+// ============================================================================
+// Load function
+// ============================================================================
+
+function emitLoadFunction(
+  type: TypeDecl,
+  lines: string[],
+  polymorphicTypeNames: Set<string>,
+): void {
+  const typeName = type.typeName.name;
+  const isPolymorphicBase = type.polymorphicDispatch !== null;
+  const hasCoercions = type.load.coercions.length > 0;
+  const returnType = isPolymorphicBase ? "interface{}" : typeName;
+
+  // Comment
+  lines.push(`// Load${typeName} creates a ${typeName} from a map[string]interface{}`);
+  if (isPolymorphicBase) {
+    lines.push("// Returns interface{} because this is a polymorphic base type that can resolve to different child types");
+  }
+
+  // Signature
+  lines.push(`func Load${typeName}(data interface{}, ctx *LoadContext) (${returnType}, error) {`);
+  lines.push(`\tresult := ${typeName}{}`);
+  lines.push("");
+
+  // 1. Polymorphic dispatch
+  if (type.polymorphicDispatch) {
+    emitPolymorphicDispatch(type.polymorphicDispatch, lines);
+  }
+
+  // 2. Coercions
+  if (hasCoercions) {
+    emitCoercions(type.load.coercions, typeName, lines);
+  }
+
+  // 3. Map loading
+  lines.push("\t// Load from map");
+  lines.push("\tif m, ok := data.(map[string]interface{}); ok {");
+
+  for (const assign of type.load.assignments) {
+    emitLoadAssignment(assign, polymorphicTypeNames, lines);
+  }
+
+  lines.push("\t}");
+  lines.push("");
+  lines.push("\treturn result, nil");
+  lines.push("}");
+  lines.push("");
+}
+
+// ============================================================================
+// Polymorphic dispatch
+// ============================================================================
+
+function emitPolymorphicDispatch(dispatch: PolymorphicDispatchDecl, lines: string[]): void {
+  lines.push("\t// Handle polymorphic types based on discriminator");
+  lines.push("\tif m, ok := data.(map[string]interface{}); ok {");
+  lines.push(`\t\tif discriminator, ok := m["${dispatch.discriminatorField}"]; ok {`);
+  lines.push("\t\t\tswitch discriminator {");
+
+  for (const variant of dispatch.variants) {
+    lines.push(`\t\t\tcase "${variant.value}":`);
+    lines.push(`\t\t\t\treturn Load${variant.typeName.name}(data, ctx)`);
+  }
+
+  // Default variant
+  if (dispatch.defaultVariant && !dispatch.defaultVariant.isSelfReference) {
+    lines.push("\t\t\tdefault:");
+    lines.push(`\t\t\t\treturn Load${dispatch.defaultVariant.typeName.name}(data, ctx)`);
+  }
+
+  lines.push("\t\t\t}");
+  lines.push("\t\t}");
+  lines.push("\t}");
+}
+
+// ============================================================================
+// Coercions
+// ============================================================================
+
+function emitCoercions(coercions: CoercionDecl[], typeName: string, lines: string[]): void {
+  lines.push("\t// Handle alternate scalar representations");
+  lines.push("\tswitch v := data.(type) {");
+
+  for (const coercion of coercions) {
+    const goType = GO_TYPE_MAP[coercion.scalarType] || coercion.scalarType;
+    lines.push(`\tcase ${goType}:`);
+    lines.push(`\t\t// Shorthand: ${goType} -> ${typeName}`);
+
+    // Build expansion map
+    const entries: string[] = [];
+    for (const assign of coercion.assignments) {
+      if (assign.isInput) {
+        entries.push(`"${assign.fieldName}": v`);
+      } else {
+        entries.push(`"${assign.fieldName}": "${assign.literalValue}"`);
+      }
+    }
+
+    lines.push(`\t\texpansion := map[string]interface{}{${entries.join(", ")}}`);
+    lines.push(`\t\treturn Load${typeName}(expansion, ctx)`);
+  }
+
+  lines.push("\t}");
+}
+
+// ============================================================================
+// Load assignment (per-property)
+// ============================================================================
+
+function emitLoadAssignment(
+  assign: LoadAssignment,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const fieldName = toPascalCase(assign.fieldName);
+  const cat = assign.category;
+
+  switch (cat.kind) {
+    case "scalar":
+      emitLoadScalar(assign, fieldName, cat.scalarType, lines);
+      break;
+    case "complex":
+      emitLoadComplex(assign, fieldName, cat.typeName, polymorphicTypeNames, lines);
+      break;
+    case "collection_scalar":
+      emitLoadCollectionScalar(assign, fieldName, cat.scalarType, lines);
+      break;
+    case "collection_complex":
+      emitLoadCollectionComplex(assign, fieldName, cat.typeName, polymorphicTypeNames, lines);
+      break;
+    case "dict":
+      emitLoadDict(assign, fieldName, lines);
+      break;
+  }
+}
+
+function emitLoadScalar(
+  assign: LoadAssignment,
+  fieldName: string,
+  scalarType: string,
+  lines: string[],
+): void {
+  const goType = GO_TYPE_MAP[scalarType] || "interface{}";
+
+  if (NUMERIC_GO_TYPES.has(goType)) {
+    emitLoadNumeric(assign, fieldName, goType, lines);
+    return;
+  }
+
+  if (goType === "interface{}") {
+    // any/unknown type
+    if (assign.isOptional) {
+      lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+      lines.push(`\t\t\tresult.${fieldName} = &val`);
+      lines.push("\t\t}");
+    } else {
+      lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+      lines.push(`\t\t\tresult.${fieldName} = val`);
+      lines.push("\t\t}");
+    }
+    return;
+  }
+
+  if (goType === "bool") {
+    if (assign.isOptional) {
+      lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+      lines.push(`\t\t\tv := val.(bool)`);
+      lines.push(`\t\t\tresult.${fieldName} = &v`);
+      lines.push("\t\t}");
+    } else {
+      lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+      lines.push(`\t\t\tresult.${fieldName} = val.(bool)`);
+      lines.push("\t\t}");
+    }
+    return;
+  }
+
+  // string (and others)
+  if (assign.isOptional) {
+    lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+    lines.push(`\t\t\tv := val.(${goType})`);
+    lines.push(`\t\t\tresult.${fieldName} = &v`);
+    lines.push("\t\t}");
+  } else {
+    lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+    lines.push(`\t\t\tresult.${fieldName} = val.(${goType})`);
+    lines.push("\t\t}");
+  }
+}
+
+function emitLoadNumeric(
+  assign: LoadAssignment,
+  fieldName: string,
+  goType: string,
+  lines: string[],
+): void {
+  const isFloat = FLOAT_GO_TYPES.has(goType);
+
+  // Build the coercion cases
+  const cases: Array<{ caseType: string; expr: string }> = [];
+
+  // int types: int, int32, int64, float64
+  // float types: int, int32, int64, float32, float64
+  cases.push({ caseType: "int", expr: `${goType}(n)` });
+  cases.push({ caseType: "int32", expr: `${goType}(n)` });
+  cases.push({ caseType: "int64", expr: `${goType}(n)` });
+
+  if (isFloat) {
+    // Identity case for float types uses direct assignment
+    if (goType === "float32") {
+      cases.push({ caseType: "float32", expr: "n" });
+      cases.push({ caseType: "float64", expr: `${goType}(n)` });
+    } else {
+      // float64
+      cases.push({ caseType: "float32", expr: `${goType}(n)` });
+      cases.push({ caseType: "float64", expr: "n" });
+    }
+  } else {
+    // int types don't include float32
+    cases.push({ caseType: "float64", expr: `${goType}(n)` });
+  }
+
+  if (assign.isOptional) {
+    lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip`);
+    lines.push(`\t\t\tvar v ${goType}`);
+    lines.push("\t\t\tswitch n := val.(type) {");
+    for (const c of cases) {
+      lines.push(`\t\t\tcase ${c.caseType}:`);
+      lines.push(`\t\t\t\tv = ${c.expr}`);
+    }
+    lines.push("\t\t\t}");
+    lines.push(`\t\t\tresult.${fieldName} = &v`);
+    lines.push("\t\t}");
+  } else {
+    lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip`);
+    lines.push(`\t\t\tvar v ${goType}`);
+    lines.push("\t\t\tswitch n := val.(type) {");
+    for (const c of cases) {
+      lines.push(`\t\t\tcase ${c.caseType}:`);
+      lines.push(`\t\t\t\tv = ${c.expr}`);
+    }
+    lines.push("\t\t\t}");
+    lines.push(`\t\t\tresult.${fieldName} = v`);
+    lines.push("\t\t}");
+  }
+}
+
+function emitLoadComplex(
+  assign: LoadAssignment,
+  fieldName: string,
+  typeName: string,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const isPolymorphic = polymorphicTypeNames.has(typeName);
+
+  lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+  lines.push(`\t\t\tif m, ok := val.(map[string]interface{}); ok {`);
+  lines.push(`\t\t\t\tloaded, _ := Load${typeName}(m, ctx)`);
+
+  if (isPolymorphic) {
+    if (assign.isOptional) {
+      lines.push(`\t\t\t\t// Polymorphic type - keep as interface{} (no pointer needed, interface{} can be nil)`);
+    } else {
+      lines.push(`\t\t\t\t// Polymorphic type - keep as interface{}`);
+    }
+    lines.push(`\t\t\t\tresult.${fieldName} = loaded`);
+  } else {
+    if (assign.isOptional) {
+      lines.push(`\t\t\t\tresult.${fieldName} = &loaded`);
+    } else {
+      lines.push(`\t\t\t\tresult.${fieldName} = loaded`);
+    }
+  }
+
+  lines.push("\t\t\t}");
+  lines.push("\t\t}");
+}
+
+function emitLoadCollectionScalar(
+  assign: LoadAssignment,
+  fieldName: string,
+  scalarType: string,
+  lines: string[],
+): void {
+  const goType = GO_TYPE_MAP[scalarType] || "interface{}";
+
+  lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+  lines.push("\t\t\tif arr, ok := val.([]interface{}); ok {");
+
+  if (goType === "interface{}") {
+    // any/unknown — assign entire array directly
+    lines.push(`\t\t\t\tresult.${fieldName} = arr`);
+  } else {
+    // Typed elements — per-element cast
+    lines.push(`\t\t\t\tresult.${fieldName} = make([]${goType}, len(arr))`);
+    lines.push("\t\t\t\tfor i, v := range arr {");
+    lines.push(`\t\t\t\t\tresult.${fieldName}[i] = v.(${goType})`);
+    lines.push("\t\t\t\t}");
+  }
+
+  lines.push("\t\t\t}");
+  lines.push("\t\t}");
+}
+
+function emitLoadCollectionComplex(
+  assign: LoadAssignment,
+  fieldName: string,
+  typeName: string,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const isPolymorphic = polymorphicTypeNames.has(typeName);
+  const goElemType = isPolymorphic ? "interface{}" : typeName;
+
+  lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+  lines.push("\t\t\tif arr, ok := val.([]interface{}); ok {");
+  lines.push(`\t\t\t\tresult.${fieldName} = make([]${goElemType}, len(arr))`);
+  lines.push("\t\t\t\tfor i, v := range arr {");
+  lines.push("\t\t\t\t\tif item, ok := v.(map[string]interface{}); ok {");
+  lines.push(`\t\t\t\t\t\tloaded, _ := Load${typeName}(item, ctx)`);
+
+  if (isPolymorphic) {
+    lines.push("\t\t\t\t\t\t// Polymorphic type - store as interface{}");
+    lines.push(`\t\t\t\t\t\tresult.${fieldName}[i] = loaded`);
+  } else {
+    lines.push(`\t\t\t\t\t\tresult.${fieldName}[i] = loaded`);
+  }
+
+  lines.push("\t\t\t\t\t}");
+  lines.push("\t\t\t\t}");
+  lines.push("\t\t\t}");
+  lines.push("\t\t}");
+}
+
+function emitLoadDict(
+  assign: LoadAssignment,
+  fieldName: string,
+  lines: string[],
+): void {
+  lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+  lines.push("\t\t\tif m, ok := val.(map[string]interface{}); ok {");
+  lines.push(`\t\t\t\tresult.${fieldName} = m`);
+  lines.push("\t\t\t}");
+  lines.push("\t\t}");
+}
+
+// ============================================================================
+// Save method
+// ============================================================================
+
+function emitSaveMethod(
+  type: TypeDecl,
+  lines: string[],
+  polymorphicTypeNames: Set<string>,
+): void {
+  const typeName = type.typeName.name;
+
+  lines.push(`// Save serializes ${typeName} to map[string]interface{}`);
+  lines.push(`func (obj *${typeName}) Save(ctx *SaveContext) map[string]interface{} {`);
+  lines.push("\tresult := make(map[string]interface{})");
+
+  for (const assign of type.save.assignments) {
+    emitSaveAssignment(assign, polymorphicTypeNames, lines);
+  }
+
+  lines.push("");
+  lines.push("\treturn result");
+  lines.push("}");
+  lines.push("");
+}
+
+// ============================================================================
+// Save assignment (per-property)
+// ============================================================================
+
+function emitSaveAssignment(
+  assign: SaveAssignment,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const fieldName = toPascalCase(assign.fieldName);
+  const cat = assign.category;
+
+  switch (cat.kind) {
+    case "scalar":
+      emitSaveScalar(assign, fieldName, cat.scalarType, lines);
+      break;
+    case "complex":
+      emitSaveComplex(assign, fieldName, cat.typeName, polymorphicTypeNames, lines);
+      break;
+    case "collection_scalar":
+      emitSaveCollectionScalar(assign, fieldName, lines);
+      break;
+    case "collection_complex":
+      emitSaveCollectionComplex(assign, fieldName, cat.typeName, polymorphicTypeNames, lines);
+      break;
+    case "dict":
+      emitSaveDict(assign, fieldName, lines);
+      break;
+  }
+}
+
+function emitSaveScalar(
+  assign: SaveAssignment,
+  fieldName: string,
+  scalarType: string,
+  lines: string[],
+): void {
+  const goType = GO_TYPE_MAP[scalarType] || "interface{}";
+
+  if (assign.isOptional) {
+    if (goType === "interface{}") {
+      // *interface{} optional
+      lines.push(`\tif obj.${fieldName} != nil {`);
+      lines.push(`\t\tresult["${assign.targetName}"] = *obj.${fieldName}`);
+      lines.push("\t}");
+    } else {
+      lines.push(`\tif obj.${fieldName} != nil {`);
+      lines.push(`\t\tresult["${assign.targetName}"] = *obj.${fieldName}`);
+      lines.push("\t}");
+    }
+  } else {
+    lines.push(`\tresult["${assign.targetName}"] = obj.${fieldName}`);
+  }
+}
+
+function emitSaveComplex(
+  assign: SaveAssignment,
+  fieldName: string,
+  typeName: string,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const isPolymorphic = polymorphicTypeNames.has(typeName);
+
+  if (isPolymorphic) {
+    if (assign.isOptional) {
+      // Optional polymorphic complex — double nil check pattern
+      lines.push(`\tif obj.${fieldName} != nil {`);
+      lines.push(`\t\t// Handle polymorphic type (stored as interface{} without pointer)`);
+      lines.push(`\t\tif obj.${fieldName} != nil {`);
+      lines.push(`\t\t\tswitch v := obj.${fieldName}.(type) {`);
+      lines.push("\t\t\tcase interface {");
+      lines.push("\t\t\t\tSave(*SaveContext) map[string]interface{}");
+      lines.push("\t\t\t}:");
+      lines.push(`\t\t\t\tresult["${assign.targetName}"] = v.Save(ctx)`);
+      lines.push("\t\t\tdefault:");
+      lines.push(`\t\t\t\tresult["${assign.targetName}"] = obj.${fieldName}`);
+      lines.push("\t\t\t}");
+      lines.push("\t\t}");
+      lines.push("\t}");
+    } else {
+      // Required polymorphic complex — blank line before, type switch
+      lines.push("");
+      lines.push("\t// Handle polymorphic type via type switch");
+      lines.push(`\tswitch v := obj.${fieldName}.(type) {`);
+      lines.push("\tcase interface {");
+      lines.push("\t\tSave(*SaveContext) map[string]interface{}");
+      lines.push("\t}:");
+      lines.push(`\t\tresult["${assign.targetName}"] = v.Save(ctx)`);
+      lines.push("\tdefault:");
+      lines.push(`\t\tresult["${assign.targetName}"] = obj.${fieldName}`);
+      lines.push("\t}");
+    }
+  } else {
+    if (assign.isOptional) {
+      lines.push(`\tif obj.${fieldName} != nil {`);
+      lines.push(`\t\tresult["${assign.targetName}"] = obj.${fieldName}.Save(ctx)`);
+      lines.push("\t}");
+    } else {
+      // Required non-polymorphic complex — blank line before
+      lines.push("");
+      lines.push(`\tresult["${assign.targetName}"] = obj.${fieldName}.Save(ctx)`);
+    }
+  }
+}
+
+function emitSaveCollectionScalar(
+  assign: SaveAssignment,
+  fieldName: string,
+  lines: string[],
+): void {
+  // Collection scalars are always saved directly (no nil check)
+  lines.push(`\tresult["${assign.targetName}"] = obj.${fieldName}`);
+}
+
+function emitSaveCollectionComplex(
+  assign: SaveAssignment,
+  fieldName: string,
+  typeName: string,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const isPolymorphic = polymorphicTypeNames.has(typeName);
+
+  lines.push(`\tif obj.${fieldName} != nil {`);
+
+  if (isPolymorphic) {
+    lines.push(`\t\tarr := make([]interface{}, len(obj.${fieldName}))`);
+    lines.push(`\t\tfor i, item := range obj.${fieldName} {`);
+    lines.push("\t\t\t// Handle polymorphic type via type switch");
+    lines.push("\t\t\tswitch v := item.(type) {");
+    lines.push("\t\t\tcase interface {");
+    lines.push("\t\t\t\tSave(*SaveContext) map[string]interface{}");
+    lines.push("\t\t\t}:");
+    lines.push("\t\t\t\tarr[i] = v.Save(ctx)");
+    lines.push("\t\t\tdefault:");
+    lines.push("\t\t\t\tarr[i] = item");
+    lines.push("\t\t\t}");
+    lines.push("\t\t}");
+    lines.push(`\t\tresult["${assign.targetName}"] = arr`);
+  } else {
+    lines.push(`\t\tarr := make([]interface{}, len(obj.${fieldName}))`);
+    lines.push(`\t\tfor i, item := range obj.${fieldName} {`);
+    lines.push("\t\t\tarr[i] = item.Save(ctx)");
+    lines.push("\t\t}");
+    lines.push(`\t\tresult["${assign.targetName}"] = arr`);
+  }
+
+  lines.push("\t}");
+}
+
+function emitSaveDict(
+  assign: SaveAssignment,
+  fieldName: string,
+  lines: string[],
+): void {
+  if (assign.isOptional) {
+    lines.push(`\tif obj.${fieldName} != nil {`);
+    lines.push(`\t\tresult["${assign.targetName}"] = obj.${fieldName}`);
+    lines.push("\t}");
+  } else {
+    lines.push(`\tresult["${assign.targetName}"] = obj.${fieldName}`);
+  }
+}
+
+// ============================================================================
+// ToWire method (provider-specific wire format)
+// ============================================================================
+
+function emitToWireMethod(type: TypeDecl, lines: string[]): void {
+  const typeName = type.typeName.name;
+  const wire = type.wire as WireDecl;
+
+  lines.push(`// ToWire converts to provider-specific wire format.`);
+  lines.push(`func (obj *${typeName}) ToWire(provider string) map[string]interface{} {`);
+  lines.push(`\tdata := obj.Save(nil)`);
+  lines.push(`\tresult := make(map[string]interface{})`);
+  lines.push(`\twireMap := map[string]map[string]string{`);
+
+  for (const mapping of wire.mappings) {
+    const entries = Object.entries(mapping.wireNames)
+      .map(([provider, wireName]) => `"${provider}": "${wireName}"`)
+      .join(", ");
+    lines.push(`\t\t"${mapping.fieldName}": {${entries}},`);
+  }
+
+  lines.push(`\t}`);
+  lines.push(`\tfor key, value := range data {`);
+  lines.push(`\t\tif mapping, ok := wireMap[key]; ok {`);
+  lines.push(`\t\t\tif wireName, ok := mapping[provider]; ok {`);
+  lines.push(`\t\t\t\tresult[wireName] = value`);
+  lines.push(`\t\t\t}`);
+  lines.push(`\t\t}`);
+  lines.push(`\t}`);
+  lines.push(`\treturn result`);
+  lines.push(`}`);
+  lines.push(``);
+}
+
+// ============================================================================
+// ToJSON / ToYAML methods
+// ============================================================================
+
+function emitToJSON(typeName: string, lines: string[]): void {
+  lines.push(`// ToJSON serializes ${typeName} to JSON string`);
+  lines.push(`func (obj *${typeName}) ToJSON() (string, error) {`);
+  lines.push("\tctx := NewSaveContext()");
+  lines.push("\tdata := obj.Save(ctx)");
+  lines.push("\tbytes, err := json.Marshal(data)");
+  lines.push("\tif err != nil {");
+  lines.push('\t\treturn "", err');
+  lines.push("\t}");
+  lines.push("\treturn string(bytes), nil");
+  lines.push("}");
+  lines.push("");
+}
+
+function emitToYAML(typeName: string, lines: string[]): void {
+  lines.push(`// ToYAML serializes ${typeName} to YAML string`);
+  lines.push(`func (obj *${typeName}) ToYAML() (string, error) {`);
+  lines.push("\tctx := NewSaveContext()");
+  lines.push("\tdata := obj.Save(ctx)");
+  lines.push("\tbytes, err := yaml.Marshal(data)");
+  lines.push("\tif err != nil {");
+  lines.push('\t\treturn "", err');
+  lines.push("\t}");
+  lines.push("\treturn string(bytes), nil");
+  lines.push("}");
+  lines.push("");
+}
+
+// ============================================================================
+// FromJSON / FromYAML functions
+// ============================================================================
+
+function emitFromJSON(typeName: string, isPolymorphic: boolean, lines: string[]): void {
+  lines.push(`// FromJSON creates ${typeName} from JSON string`);
+  if (isPolymorphic) {
+    lines.push("// Returns interface{} because this is a polymorphic base type that can resolve to different child types");
+  }
+
+  const returnType = isPolymorphic ? "interface{}" : typeName;
+  const errorReturn = isPolymorphic ? "nil" : `${typeName}{}`;
+
+  lines.push(`func ${typeName}FromJSON(jsonStr string) (${returnType}, error) {`);
+  lines.push("\tvar data map[string]interface{}");
+  lines.push("\tif err := json.Unmarshal([]byte(jsonStr), &data); err != nil {");
+  lines.push(`\t\treturn ${errorReturn}, err`);
+  lines.push("\t}");
+  lines.push("\tctx := NewLoadContext()");
+  lines.push(`\treturn Load${typeName}(data, ctx)`);
+  lines.push("}");
+  lines.push("");
+}
+
+function emitFromYAML(typeName: string, isPolymorphic: boolean, lines: string[]): void {
+  lines.push(`// FromYAML creates ${typeName} from YAML string`);
+  if (isPolymorphic) {
+    lines.push("// Returns interface{} because this is a polymorphic base type that can resolve to different child types");
+  }
+
+  const returnType = isPolymorphic ? "interface{}" : typeName;
+  const errorReturn = isPolymorphic ? "nil" : `${typeName}{}`;
+
+  lines.push(`func ${typeName}FromYAML(yamlStr string) (${returnType}, error) {`);
+  lines.push("\tvar data map[string]interface{}");
+  lines.push("\tif err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {");
+  lines.push(`\t\treturn ${errorReturn}, err`);
+  lines.push("\t}");
+  lines.push("\tctx := NewLoadContext()");
+  lines.push(`\treturn Load${typeName}(data, ctx)`);
+  lines.push("}");
+  lines.push("");
+}
+
+// ============================================================================
+// Type helpers
+// ============================================================================
+
+function getGoFieldType(
+  category: PropertyCategory,
+  isOptional: boolean,
+  polymorphicTypeNames: Set<string>,
+): string {
+  switch (category.kind) {
+    case "scalar": {
+      const goType = GO_TYPE_MAP[category.scalarType] || "interface{}";
+      if (goType === "interface{}") {
+        return isOptional ? "*interface{}" : "interface{}";
+      }
+      return isOptional ? `*${goType}` : goType;
+    }
+    case "complex": {
+      const isPolymorphic = polymorphicTypeNames.has(category.typeName);
+      if (isPolymorphic) {
+        // Polymorphic complex: always interface{} (no pointer even for optional)
+        return "interface{}";
+      }
+      return isOptional ? `*${category.typeName}` : category.typeName;
+    }
+    case "collection_scalar": {
+      const goType = GO_TYPE_MAP[category.scalarType] || "interface{}";
+      return `[]${goType}`;
+    }
+    case "collection_complex": {
+      const isPolymorphic = polymorphicTypeNames.has(category.typeName);
+      if (isPolymorphic) {
+        return "[]interface{}";
+      }
+      return `[]${category.typeName}`;
+    }
+    case "dict":
+      return "map[string]interface{}";
+  }
+}
+
+function getStructTag(fieldName: string, isOptional: boolean): string {
+  const jsonTag = isOptional ? `${fieldName},omitempty` : fieldName;
+  const yamlTag = isOptional ? `${fieldName},omitempty` : fieldName;
+  return `\`json:"${jsonTag}" yaml:"${yamlTag}"\``;
+}
+
+// ============================================================================
+// Factory functions
+// ============================================================================
+
+/** Emit a package-level factory function that creates a pre-populated struct. */
+function emitFactoryFunction(
+  typeName: string,
+  factory: FactoryDecl,
+  visitor: ExprVisitor,
+  lines: string[],
+): void {
+  const funcName = getGoFactoryName(factory.name, typeName);
+  const params = Object.entries(factory.params)
+    .map(([pName, pType]) => `${pName} ${goFactoryParamType(pType)}`)
+    .join(", ");
+
+  lines.push(`// ${funcName} creates a ${typeName} with preset field values.`);
+  lines.push(`func ${funcName}(${params}) ${typeName} {`);
+  lines.push(`\treturn ${visitor.visitExpr(factory.body)}`);
+  lines.push("}");
+  lines.push("");
+}
+
+/** Map factory name to an exported Go function name, prefixed with the type for disambiguation. */
+function getGoFactoryName(factoryName: string, typeName: string): string {
+  // Go factories are package-level functions, so prefix with type name to avoid collisions.
+  // e.g., Message.user → NewUserMessage, GuardrailResult.allow → NewAllowGuardrailResult
+  const capitalizedFactory = factoryName.charAt(0).toUpperCase() + factoryName.slice(1);
+  return `New${capitalizedFactory}${typeName}`;
+}
+
+/** Map IR type strings to Go parameter types. */
+function goFactoryParamType(typeStr: string): string {
+  switch (typeStr) {
+    case "string":
+      return "string";
+    case "boolean":
+      return "bool";
+    case "int32":
+      return "int32";
+    case "int64":
+    case "integer":
+      return "int64";
+    case "float32":
+      return "float32";
+    case "float64":
+    case "float":
+      return "float64";
+    case "unknown":
+    case "any":
+      return "interface{}";
+    default:
+      return typeStr;
+  }
+}
+
+// ============================================================================
+// Method stubs
+// ============================================================================
+
+/** Emit Go interface + comment stubs for @method-decorated helpers. */
+function emitMethodStubs(typeName: string, methods: MethodStubDecl[], lines: string[]): void {
+  // Emit an interface that the user implements in a separate file.
+  const interfaceName = `${typeName}Helpers`;
+  lines.push(`// ${interfaceName} defines helper methods for ${typeName}.`);
+  lines.push(`// Implement these in a separate file (e.g., ${typeName.toLowerCase()}_helpers.go).`);
+  lines.push(`type ${interfaceName} interface {`);
+  for (const method of methods) {
+    if (method.description) {
+      lines.push(`\t// ${toPascalCase(method.name)} — ${method.description}`);
+    }
+    lines.push(`\t${toPascalCase(method.name)}() ${goMethodReturnType(method.returns)}`);
+  }
+  lines.push("}");
+  lines.push("");
+}
+
+function goMethodReturnType(returns: string): string {
+  return GO_TYPE_MAP[returns] || returns;
+}
+
+// ============================================================================
+// Protocol interface emission
+// ============================================================================
+
+/** Map a protocol type string to a Go type. */
+function protocolGoType(typeStr: string): string {
+  // Handle nullable types
+  if (typeStr.endsWith("?")) {
+    const inner = typeStr.slice(0, -1);
+    return `*${protocolGoType(inner)}`;
+  }
+  // Handle array types
+  if (typeStr.endsWith("[]")) {
+    const inner = typeStr.slice(0, -2);
+    return `[]${protocolGoType(inner)}`;
+  }
+  if (typeStr === "Record<unknown>" || typeStr === "dictionary") return "map[string]interface{}";
+  if (typeStr === "unknown" || typeStr === "any") return "interface{}";
+  return GO_TYPE_MAP[typeStr] || typeStr;
+}
+
+/**
+ * Emit a Go interface for a protocol type.
+ */
+function emitProtocolInterface(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+
+  if (type.description) {
+    emitDescriptionComment(name, type.description, lines);
+  }
+  lines.push(`type ${name} interface {`);
+
+  for (const method of type.methods) {
+    if (method.description) {
+      lines.push(`\t// ${toPascalCase(method.name)} — ${method.description}`);
+    }
+    const params = Object.entries(method.params)
+      .map(([pName, pType]) => `${pName} ${protocolGoType(pType)}`)
+      .join(", ");
+    const ret = protocolGoType(method.returns);
+
+    if (method.sync) {
+      // Sync method — return type without error for optional
+      if (method.optional) {
+        lines.push(`\t${toPascalCase(method.name)}(${params}) ${ret}`);
+      } else {
+        lines.push(`\t${toPascalCase(method.name)}(${params}) (${ret}, error)`);
+      }
+    } else {
+      lines.push(`\t${toPascalCase(method.name)}(${params}) (${ret}, error)`);
+    }
+  }
+
+  lines.push("}");
+  lines.push("");
+}
diff --git a/schema/emitter/src/languages/go/scaffolding.ts b/schema/emitter/src/languages/go/scaffolding.ts
new file mode 100644
index 00000000..79a053dc
--- /dev/null
+++ b/schema/emitter/src/languages/go/scaffolding.ts
@@ -0,0 +1,65 @@
+/**
+ * Go scaffolding emitter — generates the LoadContext / SaveContext file.
+ *
+ * Replaces `context.go.njk` Nunjucks template with a typed TypeScript
+ * function that produces identical Go source output.
+ */
+
+// ============================================================================
+// Context interface
+// ============================================================================
+
+interface GoContextContext {
+  header: string;
+  packageName: string;
+}
+
+// ============================================================================
+// Main entry point
+// ============================================================================
+
+/**
+ * Emit the Go context file containing LoadContext and SaveContext structs.
+ *
+ * @param ctx - header string and package name
+ * @returns Complete Go source file as a string
+ */
+export function emitGoContext(ctx: GoContextContext): string {
+  const lines: string[] = [];
+
+  lines.push("// Code generated by AgentSchema emitter; DO NOT EDIT.");
+  lines.push(`// ${ctx.header}`);
+  lines.push("");
+  lines.push(`package ${ctx.packageName}`);
+  lines.push("");
+  lines.push("// LoadContext provides context for loading operations");
+  lines.push("type LoadContext struct {");
+  lines.push("\t// Add any context fields needed for loading");
+  lines.push("\t// e.g., file paths, base directories, etc.");
+  lines.push("}");
+  lines.push("");
+  lines.push("// NewLoadContext creates a new LoadContext");
+  lines.push("func NewLoadContext() *LoadContext {");
+  lines.push("\treturn &LoadContext{}");
+  lines.push("}");
+  lines.push("");
+  lines.push("// SaveContext provides context for saving operations");
+  lines.push("type SaveContext struct {");
+  lines.push("\t// Add any context fields needed for saving");
+  lines.push("\t// e.g., output directories, formatting options, etc.");
+  lines.push("}");
+  lines.push("");
+  lines.push("// NewSaveContext creates a new SaveContext");
+  lines.push("func NewSaveContext() *SaveContext {");
+  lines.push("\treturn &SaveContext{}");
+  lines.push("}");
+  lines.push("");
+  lines.push("// ptrOf returns a pointer to the given value. Used by factory functions");
+  lines.push("// to set optional (pointer) fields in struct literals.");
+  lines.push("func ptrOf[T any](v T) *T {");
+  lines.push("\treturn &v");
+  lines.push("}");
+  lines.push("");
+
+  return lines.join("\n");
+}
diff --git a/schema/emitter/src/languages/go/test-emitter.ts b/schema/emitter/src/languages/go/test-emitter.ts
new file mode 100644
index 00000000..0d9e1fee
--- /dev/null
+++ b/schema/emitter/src/languages/go/test-emitter.ts
@@ -0,0 +1,390 @@
+/**
+ * Go test emitter — BaseTestContext → Go test source code.
+ *
+ * Replaces `test.go.njk` and `_macros.njk` Nunjucks templates with
+ * typed TypeScript functions that produce identical Go test output.
+ *
+ * Each test file covers one type and contains:
+ *   - Per-example: LoadJSON, LoadYAML, Roundtrip, ToJSON, ToYAML tests
+ *   - Per-coercion: From<Title> tests for scalar-to-object expansion
+ */
+
+import {
+  BaseTestContext,
+  TestExample,
+  CoercionTest,
+  PropertyValidation,
+} from "../../ir/ast.js";
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/** Nunjucks `capitalize` filter: upper-case first char, lower-case rest. */
+function capitalize(s: string): string {
+  if (!s) return s;
+  return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+}
+
+/**
+ * Emit a validation assertion for a property.
+ *
+ * @param varName  - "instance" or "reloaded"
+ * @param v        - property validation descriptor
+ */
+function emitValidation(lines: string[], varName: string, v: PropertyValidation): void {
+  // Determine the display value for the error message — includes quotes if delimiter is "
+  const displayQuote = v.delimiter === '"' ? '"' : '';
+  const display = `${displayQuote}${v.value}${displayQuote}`;
+
+  if (v.isOptional) {
+    lines.push(`if ${varName}.${v.key} == nil || *${varName}.${v.key} != ${v.delimiter}${v.value}${v.delimiter} {`);
+    lines.push(`t.Errorf(\`Expected ${v.key} to be ${display}, got %v\`, ${varName}.${v.key})`);
+    lines.push(`}`);
+  } else {
+    lines.push(`if ${varName}.${v.key} != ${v.delimiter}${v.value}${v.delimiter} {`);
+    lines.push(`t.Errorf(\`Expected ${v.key} to be ${display}, got %v\`, ${varName}.${v.key})`);
+    lines.push(`}`);
+  }
+}
+
+// ============================================================================
+// Main entry point
+// ============================================================================
+
+/**
+ * Emit a complete Go test file for a single type.
+ *
+ * @param ctx - test context built by `buildBaseTestContext()`
+ * @returns Complete Go test source file as a string
+ */
+export function emitGoTest(ctx: BaseTestContext & { importPath: string }): string {
+  const lines: string[] = [];
+  const typeName = ctx.node.typeName.name;
+  const pkg = ctx.package ?? "";
+  const isAbstract = ctx.isAbstract;
+
+  // File header (template lines 14-16)
+  lines.push("// Code generated by AgentSchema emitter; DO NOT EDIT.");
+  lines.push("");
+  lines.push(`package ${pkg}_test`);
+
+  // Import block (template lines 17-26)
+  if (ctx.examples.length > 0 || ctx.coercions.length > 0) {
+    lines.push(""); // {% if true %}\n — blank line between package and import
+    lines.push(`import (`);
+    lines.push(`"encoding/json"`);
+    lines.push(`"testing"`);
+    lines.push(``);
+    lines.push(`"gopkg.in/yaml.v3"`);
+    lines.push(``);
+    lines.push(`"${ctx.importPath}"`);
+    lines.push(`)`);
+  }
+  lines.push(""); // {% endif %}\n (line 26)
+  lines.push(""); // blank line 27
+
+  // Per-example test functions (template lines 28-234)
+  for (let i = 0; i < ctx.examples.length; i++) {
+    const sample = ctx.examples[i];
+    const isFirst = i === 0;
+    const suffix = isFirst ? "" : String(i);
+
+    lines.push(""); // {% for %}\n — loop body starts with \n
+    emitLoadJSONTest(lines, typeName, pkg, suffix, sample, isAbstract);
+    lines.push("");
+    emitLoadYAMLTest(lines, typeName, pkg, suffix, sample, isAbstract);
+    lines.push("");
+    emitRoundtripTest(lines, typeName, pkg, suffix, sample, isAbstract);
+    lines.push("");
+    emitToJSONTest(lines, typeName, pkg, suffix, sample, isAbstract);
+    lines.push("");
+    emitToYAMLTest(lines, typeName, pkg, suffix, sample, isAbstract);
+    lines.push(""); // blank line 233
+  }
+  lines.push(""); // {% endfor %}\n (line 234)
+
+  // Coercion test functions (template lines 235-271)
+  if (ctx.coercions.length > 0) {
+    lines.push(""); // {% if true %}\n — if body starts with \n
+    for (let i = 0; i < ctx.coercions.length; i++) {
+      const alt = ctx.coercions[i];
+      const isFirst = i === 0;
+      const suffix = isFirst ? "" : String(i + 1);
+
+      lines.push(""); // {% for %}\n — loop body starts with \n
+      emitCoercionTest(lines, typeName, pkg, suffix, alt, isAbstract);
+      lines.push(""); // blank line 269
+    }
+    lines.push(""); // {% endfor %}\n (line 270)
+    lines.push(""); // {% endif %}\n (line 271)
+  } else {
+    lines.push(""); // {% if false %}...{% endif %}\n — 1 \n
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+// ============================================================================
+// Per-example test emitters
+// ============================================================================
+
+function emitJsonDataBlock(lines: string[], sample: TestExample): void {
+  lines.push("jsonData := `");
+  for (const line of sample.json) {
+    lines.push(line);
+  }
+  lines.push("`");
+}
+
+function emitYamlDataBlock(lines: string[], sample: TestExample): void {
+  lines.push("yamlData := `");
+  for (const line of sample.yaml) {
+    lines.push(line);
+  }
+  lines.push("`");
+}
+
+function emitJsonUnmarshal(lines: string[], varName: string = "data"): void {
+  lines.push(`var ${varName} map[string]interface{}`);
+  lines.push(`if err := json.Unmarshal([]byte(jsonData), &${varName}); err != nil {`);
+  lines.push(`t.Fatalf("Failed to parse JSON: %v", err)`);
+  lines.push(`}`);
+}
+
+function emitYamlUnmarshal(lines: string[], varName: string = "data"): void {
+  lines.push(`var ${varName} map[string]interface{}`);
+  lines.push(`if err := yaml.Unmarshal([]byte(yamlData), &${varName}); err != nil {`);
+  lines.push(`t.Fatalf("Failed to parse YAML: %v", err)`);
+  lines.push(`}`);
+}
+
+function emitLoadCall(
+  lines: string[],
+  typeName: string,
+  pkg: string,
+  ctxVar: string,
+  dataVar: string,
+  instanceVar: string,
+): void {
+  lines.push(`${ctxVar} := ${pkg}.NewLoadContext()`);
+  lines.push(`${instanceVar}, err := ${pkg}.Load${typeName}(${dataVar}, ${ctxVar})`);
+  lines.push(`if err != nil {`);
+  lines.push(`t.Fatalf("Failed to load ${typeName}: %v", err)`);
+  lines.push(`}`);
+}
+
+function emitAbstractExampleValidations(
+  lines: string[],
+  hasValidations: boolean,
+): void {
+  lines.push("// Polymorphic types return interface{}, extract common fields via reflection or type-specific access");
+  lines.push("_ = instance // Load succeeded, exact type depends on discriminator");
+  if (hasValidations) {
+    lines.push("// Note: Validation skipped for polymorphic base types - test child types directly");
+  }
+}
+
+function emitConcreteExampleValidations(
+  lines: string[],
+  varName: string,
+  validations: PropertyValidation[],
+): void {
+  if (validations.length > 0) {
+    for (const v of validations) {
+      emitValidation(lines, varName, v);
+    }
+  } else {
+    lines.push(`_ = ${varName} // No scalar properties to validate`);
+  }
+}
+
+// ---- LoadJSON ----
+
+function emitLoadJSONTest(
+  lines: string[],
+  typeName: string,
+  pkg: string,
+  suffix: string,
+  sample: TestExample,
+  isAbstract: boolean,
+): void {
+  lines.push(`// Test${typeName}LoadJSON${suffix} tests loading ${typeName} from JSON`);
+  lines.push(`func Test${typeName}LoadJSON${suffix}(t *testing.T) {`);
+  emitJsonDataBlock(lines, sample);
+  emitJsonUnmarshal(lines);
+  lines.push("");
+  emitLoadCall(lines, typeName, pkg, "ctx", "data", "instance");
+  if (isAbstract) {
+    emitAbstractExampleValidations(lines, sample.validations.length > 0);
+  } else {
+    emitConcreteExampleValidations(lines, "instance", sample.validations);
+  }
+  lines.push("}");
+}
+
+// ---- LoadYAML ----
+
+function emitLoadYAMLTest(
+  lines: string[],
+  typeName: string,
+  pkg: string,
+  suffix: string,
+  sample: TestExample,
+  isAbstract: boolean,
+): void {
+  lines.push(`// Test${typeName}LoadYAML${suffix} tests loading ${typeName} from YAML`);
+  lines.push(`func Test${typeName}LoadYAML${suffix}(t *testing.T) {`);
+  emitYamlDataBlock(lines, sample);
+  emitYamlUnmarshal(lines);
+  lines.push("");
+  emitLoadCall(lines, typeName, pkg, "ctx", "data", "instance");
+  if (isAbstract) {
+    emitAbstractExampleValidations(lines, sample.validations.length > 0);
+  } else {
+    emitConcreteExampleValidations(lines, "instance", sample.validations);
+  }
+  lines.push("}");
+}
+
+// ---- Roundtrip ----
+
+function emitRoundtripTest(
+  lines: string[],
+  typeName: string,
+  pkg: string,
+  suffix: string,
+  sample: TestExample,
+  isAbstract: boolean,
+): void {
+  lines.push(`// Test${typeName}Roundtrip${suffix} tests load -> save -> load produces equivalent data`);
+  lines.push(`func Test${typeName}Roundtrip${suffix}(t *testing.T) {`);
+  emitJsonDataBlock(lines, sample);
+  emitJsonUnmarshal(lines);
+  lines.push("");
+
+  lines.push(`loadCtx := ${pkg}.NewLoadContext()`);
+  lines.push(`instance, err := ${pkg}.Load${typeName}(data, loadCtx)`);
+  lines.push(`if err != nil {`);
+  lines.push(`t.Fatalf("Failed to load ${typeName}: %v", err)`);
+  lines.push(`}`);
+  if (isAbstract) {
+    lines.push("// Polymorphic roundtrip testing requires type-specific handling");
+    lines.push("_ = instance // Load succeeded, exact type depends on discriminator");
+    lines.push("// Note: Roundtrip test skipped for polymorphic base types - test child types directly");
+  } else {
+    lines.push(`saveCtx := ${pkg}.NewSaveContext()`);
+    lines.push(`savedData := instance.Save(saveCtx)`);
+    lines.push("");
+    lines.push(`reloaded, err := ${pkg}.Load${typeName}(savedData, loadCtx)`);
+    lines.push(`if err != nil {`);
+    lines.push(`t.Fatalf("Failed to reload ${typeName}: %v", err)`);
+    lines.push(`}`);
+    emitConcreteExampleValidations(lines, "reloaded", sample.validations);
+  }
+  lines.push("}");
+}
+
+// ---- ToJSON ----
+
+function emitToJSONTest(
+  lines: string[],
+  typeName: string,
+  pkg: string,
+  suffix: string,
+  sample: TestExample,
+  isAbstract: boolean,
+): void {
+  lines.push(`// Test${typeName}ToJSON${suffix} tests that ToJSON produces valid JSON`);
+  lines.push(`func Test${typeName}ToJSON${suffix}(t *testing.T) {`);
+  emitJsonDataBlock(lines, sample);
+  emitJsonUnmarshal(lines);
+  lines.push("");
+  emitLoadCall(lines, typeName, pkg, "ctx", "data", "instance");
+  if (isAbstract) {
+    lines.push("// Polymorphic ToJSON requires type-specific handling");
+    lines.push("_ = instance // Load succeeded, exact type depends on discriminator");
+    lines.push("// Note: ToJSON test skipped for polymorphic base types - test child types directly");
+  } else {
+    lines.push("jsonOutput, err := instance.ToJSON()");
+    lines.push("if err != nil {");
+    lines.push(`t.Fatalf("Failed to convert to JSON: %v", err)`);
+    lines.push("}");
+    lines.push("");
+    lines.push("var parsed map[string]interface{}");
+    lines.push("if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {");
+    lines.push(`t.Fatalf("Failed to parse generated JSON: %v", err)`);
+    lines.push("}");
+  }
+
+  lines.push("}");
+}
+
+// ---- ToYAML ----
+
+function emitToYAMLTest(
+  lines: string[],
+  typeName: string,
+  pkg: string,
+  suffix: string,
+  sample: TestExample,
+  isAbstract: boolean,
+): void {
+  lines.push(`// Test${typeName}ToYAML${suffix} tests that ToYAML produces valid YAML`);
+  lines.push(`func Test${typeName}ToYAML${suffix}(t *testing.T) {`);
+  emitJsonDataBlock(lines, sample);
+  emitJsonUnmarshal(lines);
+  lines.push("");
+  emitLoadCall(lines, typeName, pkg, "ctx", "data", "instance");
+  if (isAbstract) {
+    lines.push("// Polymorphic ToYAML requires type-specific handling");
+    lines.push("_ = instance // Load succeeded, exact type depends on discriminator");
+    lines.push("// Note: ToYAML test skipped for polymorphic base types - test child types directly");
+  } else {
+    lines.push("yamlOutput, err := instance.ToYAML()");
+    lines.push("if err != nil {");
+    lines.push(`t.Fatalf("Failed to convert to YAML: %v", err)`);
+    lines.push("}");
+    lines.push("");
+    lines.push("var parsed map[string]interface{}");
+    lines.push("if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {");
+    lines.push(`t.Fatalf("Failed to parse generated YAML: %v", err)`);
+    lines.push("}");
+  }
+
+  lines.push("}");
+}
+
+// ============================================================================
+// Coercion test emitter
+// ============================================================================
+
+function emitCoercionTest(
+  lines: string[],
+  typeName: string,
+  pkg: string,
+  suffix: string,
+  alt: CoercionTest,
+  isAbstract: boolean,
+): void {
+  const title = capitalize(alt.title);
+
+  lines.push(`// Test${typeName}From${title}${suffix} tests loading ${typeName} from ${alt.scalarType}`);
+  lines.push(`func Test${typeName}From${title}${suffix}(t *testing.T) {`);
+  lines.push(`ctx := ${pkg}.NewLoadContext()`);
+  lines.push(`instance, err := ${pkg}.Load${typeName}(${alt.value}, ctx)`);
+  lines.push(`if err != nil {`);
+  lines.push(`t.Fatalf("Failed to load ${typeName} from ${alt.scalarType}: %v", err)`);
+  lines.push(`}`);
+  if (isAbstract) {
+    lines.push("// Polymorphic alternate loading requires type-specific handling");
+    lines.push("_ = instance // Load succeeded, exact type depends on discriminator");
+    if (alt.validations.length > 0) {
+      lines.push("// Note: Validation skipped for polymorphic base types - test child types directly");
+    }
+  } else {
+    emitConcreteExampleValidations(lines, "instance", alt.validations);
+  }
+
+  lines.push("}");
+}
diff --git a/schema/emitter/src/languages/go/visitor.ts b/schema/emitter/src/languages/go/visitor.ts
new file mode 100644
index 00000000..b36eaccb
--- /dev/null
+++ b/schema/emitter/src/languages/go/visitor.ts
@@ -0,0 +1,88 @@
+/**
+ * Go expression visitor — Expr IR → Go source fragments.
+ */
+
+import { Expr, Construct, VariantConstruct, ArrayLiteral, TypeRegistry } from "../../ir/expansion.js";
+import { ExprVisitor, toPascalCase, assertNever } from "../../ir/visitor.js";
+
+export class GoExprVisitor implements ExprVisitor {
+  registry?: TypeRegistry;
+
+  constructor(registry?: TypeRegistry) {
+    this.registry = registry;
+  }
+
+  visitExpr(expr: Expr): string {
+    switch (expr.kind) {
+      case "string":
+        return `"${this.escapeString(expr.value)}"`;
+      case "number":
+        return String(expr.value);
+      case "boolean":
+        return expr.value ? "true" : "false";
+      case "null":
+        return "nil";
+      case "param":
+        return expr.name;
+      case "construct":
+        return this.visitConstruct(expr);
+      case "variant":
+        return this.visitVariant(expr);
+      case "array":
+        return this.visitArray(expr);
+      case "dict":
+        return `map[string]interface{}{${expr.entries.map(e => `"${e.key}": ${this.visitExpr(e.value)}`).join(", ")}}`;
+      case "field_read":
+        return `${expr.objectName}.${toPascalCase(expr.fieldName)}`;
+      default:
+        return assertNever(expr);
+    }
+  }
+
+  private visitConstruct(expr: Construct): string {
+    const typeName = expr.typeName.name;
+    if (expr.fields.length === 0) {
+      return `${typeName}{}`;
+    }
+    // Look up the target type to check which fields are optional (pointer types in Go)
+    const typeNode = this.registry?.get(typeName);
+    const fields = expr.fields.map(f => {
+      const val = this.visitExpr(f.value);
+      const prop = typeNode?.properties.find(p => p.name === f.propertyName);
+      // Optional fields are pointers in Go — wrap scalar values with a helper
+      const needsAddr = prop?.isOptional && !prop.isCollection && !prop.isDict;
+      return `${toPascalCase(f.propertyName)}: ${needsAddr ? `ptrOf(${val})` : val}`;
+    }).join(", ");
+    return `${typeName}{ ${fields} }`;
+  }
+
+  private visitVariant(expr: VariantConstruct): string {
+    // Go child types are full structs with an explicit discriminator field.
+    const variantName = expr.variantTypeName.name;
+    // Include the discriminator (e.g., Kind: "text") since Go has no default field values.
+    const discField = `${toPascalCase(expr.discriminator)}: "${expr.discriminatorValue}"`;
+    const dataFields = expr.fields.map(f =>
+      `${toPascalCase(f.propertyName)}: ${this.visitExpr(f.value)}`
+    );
+    const allFields = [discField, ...dataFields].join(", ");
+    return `${variantName}{ ${allFields} }`;
+  }
+
+  private visitArray(expr: ArrayLiteral): string {
+    const elementType = expr.elementTypeName.name;
+    // Polymorphic types are stored as []interface{} in Go (no inheritance).
+    // A type is polymorphic if it has child types in the registry.
+    const typeNode = this.registry?.get(elementType);
+    const isPolymorphic = typeNode !== undefined && typeNode.childTypes.length > 0;
+    const goElementType = isPolymorphic ? "interface{}" : elementType;
+    if (expr.items.length === 0) {
+      return `[]${goElementType}{}`;
+    }
+    const items = expr.items.map(i => this.visitExpr(i)).join(", ");
+    return `[]${goElementType}{${items}}`;
+  }
+
+  private escapeString(s: string): string {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+}
diff --git a/schema/emitter/src/languages/markdown/driver.ts b/schema/emitter/src/languages/markdown/driver.ts
new file mode 100644
index 00000000..6004d94a
--- /dev/null
+++ b/schema/emitter/src/languages/markdown/driver.ts
@@ -0,0 +1,344 @@
+import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
+import { EmitTarget, PromptyEmitterOptions } from "../../lib.js";
+import { enumerateTypes, PropertyNode, TypeName, TypeNode } from "../../ir/ast.js";
+import { GeneratorOptions, filterNodes } from "../../emitter.js";
+import * as YAML from 'yaml';
+
+function deepMerge<T extends Record<string, any>>(...objects: T[]): T {
+  return objects.reduce((acc, obj) => {
+    Object.keys(obj).forEach((key) => {
+      const accValue = acc[key as keyof T];
+      const objValue = obj[key as keyof T];
+
+      if (typeof accValue === "object" && typeof objValue === "object") {
+        acc[key as keyof T] = deepMerge(accValue, objValue);
+      } else {
+        acc[key as keyof T] = objValue;
+      }
+    });
+    return acc;
+  }, {} as T);
+}
+
+function emitIndexMarkdown(
+  types: TypeNode[],
+  rootObject: string,
+  childTypes: { source: string; target: string }[],
+  compositionTypes: { source: string; target: string }[],
+): string {
+  let out = `---
+title: "AgentSchema"
+description: "Overview of declarative agent types in AgentSchema."
+slug: "reference/index"
+sidebar:
+  order: 1
+---
+
+The following diagram illustrates the classes and their relationships for declarative agents.
+The root [object](${rootObject.toLowerCase()}/) represents the main entry point for the system.
+
+\`\`\`mermaid
+---
+title: ${rootObject} and Related Types
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram`;
+  for (const type of types) {
+    out += `\n    class ${type.typeName.name} {`;
+    if (type.isAbstract) {
+      out += `\n      <<abstract>>`;
+    }
+    for (const prop of type.properties) {
+      out += `\n        +${prop.typeName.name}${prop.isCollection ? "[]" : ""} ${prop.name}`;
+    }
+    out += `\n    }`;
+  }
+  for (const child of childTypes) {
+    out += `\n    ${child.source} <|-- ${child.target}`;
+  }
+  for (const comp of compositionTypes) {
+    out += `\n    ${comp.source} *-- ${comp.target}`;
+  }
+  out += `\n\`\`\`\n`;
+  return out;
+}
+
+function emitFileMarkdown(
+  node: TypeNode,
+  yml: string | undefined,
+  md: string | undefined,
+  compositionTypes: TypeNode[],
+  alternateCtors: { title: string; description: string; scalar: string; simple: string; expanded: string }[],
+  parent: TypeNode | undefined,
+): string {
+  let out = `---
+title: "${node.typeName.name}"
+description: "Documentation for the ${node.typeName.name} type."
+slug: "reference/${node.typeName.name.toLowerCase()}"
+---
+
+${node.description}
+
+## Class Diagram
+
+\`\`\`mermaid
+---
+title: ${node.typeName.name}
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram`;
+
+  if (parent) {
+    out += `\n    class ${parent.typeName.name} {`;
+    for (const prop of parent.properties) {
+      out += `\n        +${prop.typeName.name}${prop.isCollection ? "[]" : ""} ${prop.name}`;
+    }
+    out += `\n    }`;
+    out += `\n    ${parent.typeName.name} <|-- ${node.typeName.name}`;
+  }
+
+  out += `\n    class ${node.typeName.name} {`;
+  if (node.isAbstract) {
+    out += `\n      <<abstract>>`;
+  }
+  for (const prop of node.properties) {
+    out += `\n        +${prop.typeName.name}${prop.isCollection ? "[]" : ""} ${prop.name}`;
+  }
+  out += `\n    }`;
+
+  for (const type of node.childTypes) {
+    out += `\n    class ${type.typeName.name} {`;
+    for (const prop of type.properties) {
+      out += `\n        +${prop.typeName.name}${prop.isCollection ? "[]" : ""} ${prop.name}`;
+    }
+    out += `\n    }`;
+    out += `\n    ${node.typeName.name} <|-- ${type.typeName.name}`;
+  }
+
+  for (const type of compositionTypes) {
+    out += `\n    class ${type.typeName.name} {`;
+    for (const prop of type.properties) {
+      out += `\n        +${prop.typeName.name}${prop.isCollection ? "[]" : ""} ${prop.name}`;
+    }
+    out += `\n    }`;
+    out += `\n    ${node.typeName.name} *-- ${type.typeName.name}`;
+  }
+
+  out += `\n\`\`\``;
+
+  if (md) {
+    out += `\n\n## Markdown Example\n\n\`\`\`markdown\n${md.trim()}\n\`\`\``;
+  }
+
+  if (yml) {
+    out += `\n\n## Yaml Example\n\n\`\`\`yaml\n${yml.trim()}\n\`\`\``;
+  }
+
+  if (node.properties.length > 0) {
+    out += `\n\n## Properties\n\n| Name | Type | Description |\n| ---- | ---- | ----------- |`;
+    for (const prop of node.properties) {
+      out += `\n| ${prop.name} | ${renderType(prop)} | ${prop.description.trim()}${renderChildTypes(prop)} |`;
+    }
+  }
+
+  if (node.methods.length > 0) {
+    out += `\n\n## Helper Methods\n\nThe following helper methods are declared via \`@method\` and must be implemented by every runtime. Idiomatic language shape (e.g. zero-param accessor may be a property) is chosen per-language by the emitter.\n\n| Name | Signature | Description |\n| ---- | --------- | ----------- |`;
+    for (const method of node.methods) {
+      const paramList = Object.entries(method.params)
+        .map(([n, t]) => `${n}: ${t}`)
+        .join(", ");
+      const sig = `${method.name}(${paramList}) -> ${method.returns}`;
+      const flags: string[] = [];
+      if (method.optional) flags.push("optional");
+      if (method.sync) flags.push("sync");
+      const suffix = flags.length > 0 ? ` _(${flags.join(", ")})_` : "";
+      out += `\n| \`${method.name}\` | \`${sig}\`${suffix} | ${method.description.trim()} |`;
+    }
+  }
+
+  if (node.factories.length > 0) {
+    out += `\n\n## Factory Methods\n\nThe following factory methods are declared via \`@factory\` and are generated automatically by the emitter in every language.\n`;
+    for (const factory of node.factories) {
+      const paramList = Object.entries(factory.params)
+        .map(([n, t]) => `${n}: ${t}`)
+        .join(", ");
+      out += `\n- \`${factory.name}(${paramList})\``;
+    }
+  }
+
+  if (node.childTypes.length > 0) {
+    out += `\n\n## Child Types\n\nThe following types extend \`${node.typeName.name}\`:\n`;
+    for (const type of node.childTypes) {
+      out += `\n- [${type.typeName.name}](../${type.typeName.name.toLowerCase()}/)`;
+    }
+  }
+
+  if (compositionTypes.length > 0) {
+    out += `\n\n## Composed Types\n\nThe following types are composed within \`${node.typeName.name}\`:\n`;
+    for (const type of compositionTypes) {
+      out += `\n- [${type.typeName.name}](../${type.typeName.name.toLowerCase()}/)`;
+    }
+  }
+
+  if (alternateCtors.length > 0) {
+    out += `\n\n## Alternate Constructions\n\nThe following alternate constructions are available for \`${node.typeName.name}\`.\nThese allow for simplified creation of instances using a single property.`;
+    for (const ctor of alternateCtors) {
+      out += `\n\n### ${ctor.scalar}`;
+      if (ctor.title) {
+        out += ` ${ctor.title}`;
+      }
+      out += `\n`;
+      if (ctor.description) {
+        out += `\n${ctor.description}\n`;
+      }
+      out += `\nThe following simplified representation can be used:\n\n\`\`\`yaml\n${ctor.simple.trim()}\n\`\`\`\n\nThis is equivalent to the full representation:\n\n\`\`\`yaml\n${ctor.expanded.trim()}\n\`\`\``;
+    }
+  }
+
+  out += `\n`;
+  return out;
+}
+
+export const generateMarkdown = async (context: EmitContext<PromptyEmitterOptions>, node: TypeNode, emitTarget: EmitTarget, options?: GeneratorOptions) => {
+
+  const rootObject = context.options["root-alias"] || "AgentDefinition";
+
+  const nodes = filterNodes(Array.from(enumerateTypes(node)), options);
+
+  const childTypes: { source: string, target: string }[] = nodes.map(n => {
+    return n.childTypes.map(c => {
+      return { source: n.typeName.name, target: c.typeName.name };
+    });
+  }).flat();
+
+  const compositionTypes: { source: string, target: string }[] = nodes.map(n => {
+    return n.properties.filter(p => !p.isScalar).map(c => {
+      return { source: n.typeName.name, target: c.typeName.name };
+    });
+  }).flat();
+
+  const readmeContent = emitIndexMarkdown(nodes, rootObject, childTypes, compositionTypes);
+  await emitMarkdownFile(context, "index", readmeContent, emitTarget["output-dir"]);
+
+  const findNodeByName = (name: TypeName): TypeNode | undefined => {
+    return nodes.find(n => n.typeName.name === name.name && n.typeName.namespace === name.namespace);
+  }
+
+  for (const node of nodes) {
+    const sample = node.properties.filter(p => p.samples.length > 0).map(p => p.samples[0].sample);
+    let yml: string | undefined = undefined;
+    let md: string | undefined = undefined;
+    if (sample.length > 0) {
+      const s = deepMerge(...sample);
+      yml = YAML.stringify(s, { indent: 2 });
+      if ("instructions" in s) {
+        const instructions = s.instructions;
+        delete s.instructions;
+        md = `---\n${YAML.stringify(s, { indent: 2 })}---\n${instructions}`;
+      }
+    }
+    const markdown = emitFileMarkdown(
+      node,
+      yml,
+      md,
+      getCompositionTypes(node),
+      generateCoercions(node),
+      node.base ? findNodeByName(node.base) : undefined,
+    );
+
+    await emitMarkdownFile(context, node.typeName.name, markdown, emitTarget["output-dir"]);
+  }
+}
+
+export const renderType = (prop: PropertyNode) => {
+  const arrayString = prop.isCollection ? "[]" : "";
+  if (prop.isScalar) {
+    return prop.typeName.name + arrayString;
+  } else if (prop.isDict) {
+    return `${prop.typeName.name + arrayString}`;
+  } else {
+    return `[${prop.typeName.name + arrayString}](../${prop.typeName.name.toLowerCase()}/)`;
+  }
+};
+
+export const renderChildTypes = (node: PropertyNode) => {
+  if (!node.isScalar && node.type) {
+    const childTypes = node.type.childTypes.map(c => {
+      return `[${c.typeName.name}](../${c.typeName.name.toLowerCase()}/)`;
+    });
+
+    if (childTypes.length === 0) {
+      return "";
+    }
+
+    return `(Related Types: ${childTypes.join(", ")})`;
+  }
+  return "";
+};
+
+export const getChildTypes = (node: TypeNode): { source: string, target: string }[] => {
+  return node.childTypes.flatMap(c => [{
+    source: node.typeName.name,
+    target: c.typeName.name
+  }, ...getChildTypes(c)]);
+};
+
+export const getCompositionTypes = (node: TypeNode): TypeNode[] => {
+  const nonScalars = node.properties.filter(p => !p.isScalar && !p.isDict);
+  return nonScalars.flatMap(c => c.type ? [c.type] : []);
+};
+
+const typeExampleMapper: Record<string, string> = {
+  "string": "\"example\"",
+  "number": "5",
+  "boolean": "true",
+  "int64": "5",
+  "int32": "5",
+  "float64": "3.14",
+  "float32": "3.14",
+  "integer": "5",
+  "float": "3.14",
+  "numeric": "3.14",
+};
+
+export const generateCoercions = (node: TypeNode): { title: string; description: string; scalar: string; simple: string, expanded: string }[] => {
+  if (node.coercions && node.coercions.length > 0) {
+    const alts: { title: string; description: string; scalar: string; simple: string, expanded: string }[] = [];
+    for (const alt of node.coercions) {
+      const scalar = alt.scalar;
+      const sample = typeExampleMapper[scalar] ? typeExampleMapper[scalar] : "example";
+
+      const simple: { [key: string]: any } = {};
+      simple[alt.title || "value"] = "\"{value}\"";
+      const expansion: { [key: string]: any } = {};
+      expansion[alt.title || "value"] = alt.expansion;
+
+      alts.push({
+        title: alt.title || "",
+        description: alt.description || "",
+        scalar: scalar,
+        simple: YAML.stringify(simple, { indent: 2 }).replace("\"{value}\"", sample).replaceAll("'", ""),
+        expanded: YAML.stringify(expansion, { indent: 2 }).replace("\"{value}\"", sample)
+      });
+    }
+    return alts;
+  } else {
+    return [];
+  }
+};
+
+const emitMarkdownFile = async (context: EmitContext<PromptyEmitterOptions>, name: string, markdown: string, outputDir?: string) => {
+  const dir = outputDir || `${context.emitterOutputDir}/markdown`;
+  await emitFile(context.program, {
+    path: resolvePath(dir, `${name}.md`),
+    content: markdown,
+  });
+}
diff --git a/schema/emitter/src/python.ts b/schema/emitter/src/languages/python/driver.ts
similarity index 51%
rename from schema/emitter/src/python.ts
rename to schema/emitter/src/languages/python/driver.ts
index 4a816eab..57323458 100644
--- a/schema/emitter/src/python.ts
+++ b/schema/emitter/src/languages/python/driver.ts
@@ -1,8 +1,8 @@
 import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { existsSync } from "fs";
 import { dirname, resolve } from "path";
-import { EmitTarget, PromptyEmitterOptions } from "./lib.js";
+import { EmitTarget, PromptyEmitterOptions } from "../../lib.js";
 import {
   enumerateTypes,
   PropertyNode,
@@ -12,12 +12,17 @@ import {
   PythonInitContext,
   PythonLoadContextContext,
   BaseTestContext
-} from "./ast.js";
-import { GeneratorOptions, filterNodes } from "./emitter.js";
-import { getCombinations, scalarValue, toSnakeCase } from "./utilities.js";
-import { createTemplateEngine } from "./template-engine.js";
-import { buildBaseTestContext, pythonTestOptions } from "./test-context.js";
-import * as YAML from "yaml";
+} from "../../ir/ast.js";
+import { resolveFactoryExpr, resolveCoerceExpr, TypeRegistry, collectExprTypeRefs } from "../../ir/expansion.js";
+import { ExprVisitor, renderObjectLiteral } from "../../ir/visitor.js";
+import { PythonExprVisitor } from "./visitor.js";
+import { GeneratorOptions, filterNodes } from "../../emitter.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+import { buildBaseTestContext, pythonTestOptions } from "../../testing/test-context.js";
+import { lowerFile, collectPolymorphicTypeNames } from "../../ir/lower.js";
+import { emitPythonFile as emitPythonFileDecl } from "./emitter.js";
+import { emitPythonContext, emitPythonInit } from "./scaffolding.js";
+import { emitPythonTest, emitPythonTestContext } from "./test-emitter.js";
 
 /**
  * Type mapping from TypeSpec scalar types to Python types.
@@ -42,19 +47,20 @@ export const pythonTypeMapper: Record<string, string> = {
 
 /**
  * Main entry point for Python code generation.
- * Prepares pure data contexts and delegates rendering to Nunjucks templates.
+ * Prepares data contexts and delegates rendering to inline emitter functions.
  */
 export const generatePython = async (
   context: EmitContext<PromptyEmitterOptions>,
-  templateDir: string,
   node: TypeNode,
   emitTarget: EmitTarget,
   options?: GeneratorOptions
 ): Promise<void> => {
-  // Create template engine with Python templates + shared macros
-  const engine = createTemplateEngine(templateDir, 'python');
+  const allTypes = Array.from(enumerateTypes(node));
+  const nodes = filterNodes(allTypes, options);
 
-  const nodes = filterNodes(Array.from(enumerateTypes(node)), options);
+  // Build the expression IR infrastructure
+  const registry = TypeRegistry.fromTypeGraph(allTypes);
+  const visitor = new PythonExprVisitor(registry);
 
   // Determine package name from root node namespace (e.g., "Prompty" -> "prompty")
   const packageName = node.typeName.namespace.toLowerCase();
@@ -67,34 +73,42 @@ export const generatePython = async (
 
   // Render LoadContext file
   const contextContext = buildLoadContextContext();
-  const contextContent = engine.render('context.py.njk', contextContext);
+  const contextContent = emitPythonContext(contextContext.header);
   await emitPythonFile(context, '_context.py', contextContent, emitTarget["output-dir"]);
 
   // Render LoadContext tests
   if (emitTarget["test-dir"]) {
     const testContextContext = buildLoadContextContext(importPath);
-    const testContextContent = engine.render('test_context.py.njk', testContextContext);
+    const testContextContent = emitPythonTestContext(testContextContext.header, importPath);
     await emitPythonFile(context, 'test_context.py', testContextContent, emitTarget["test-dir"]);
   }
 
   // Render init file
   const initContext = buildInitContext(nodes);
-  const initContent = engine.render('init.py.njk', initContext);
+  const initContent = emitPythonInit(initContext.baseTypes, initContext.types);
   await emitPythonFile(context, '__init__.py', initContent, emitTarget["output-dir"]);
 
+  // Collect polymorphic type names once for the full type graph
+  const polymorphicTypeNames = new Set<string>();
+  for (const n of allTypes) {
+    for (const name of collectPolymorphicTypeNames(n, registry)) {
+      polymorphicTypeNames.add(name);
+    }
+  }
+
   // Render each base type and its children as a single file
   for (const n of nodes) {
     // Skip child types - they're rendered with their parent
     if (!n.base) {
-      const fileContext = buildFileContext(n);
-      const fileContent = engine.render('file.py.njk', fileContext);
+      const fileDecl = lowerFile(n, registry, polymorphicTypeNames);
+      const fileContent = emitPythonFileDecl(fileDecl, visitor);
       await emitPythonFile(context, `_${n.typeName.name}.py`, fileContent, emitTarget["output-dir"]);
     }
 
-    // Render test file for each type
-    if (emitTarget["test-dir"]) {
+    // Render test file for each type (skip protocols — they have no data to test)
+    if (emitTarget["test-dir"] && !n.isProtocol) {
       const testContext = buildTestContext(n, importPath);
-      const testContent = engine.render('test.py.njk', testContext);
+      const testContent = emitPythonTest(testContext);
       await emitPythonFile(context, `test_${toSnakeCase(n.typeName.name)}.py`, testContent, emitTarget["test-dir"]);
     }
   }
@@ -114,8 +128,9 @@ export const generatePython = async (
 };
 
 /**
- * Format Python files using ruff and black formatters.
+ * Format Python files using ruff linter and formatter.
  * Runs formatters via uv from the Python project root (where pyproject.toml is located).
+ * CI enforces `ruff check` and `ruff format --check`, so both must pass.
  */
 function formatPythonFiles(outputDir: string, testDir?: string): void {
   // Find the Python project root by looking for pyproject.toml
@@ -128,26 +143,26 @@ function formatPythonFiles(outputDir: string, testDir?: string): void {
   const dirs = [outputDir, ...(testDir ? [testDir] : [])];
 
   for (const dir of dirs) {
-    // Run ruff check with auto-fix
+    // Run ruff check with auto-fix (linting)
     try {
-      execSync(`uv run ruff check --fix "${dir}"`, {
+      execFileSync("uv", ["run", "ruff", "check", "--fix", dir], {
         cwd: projectRoot,
         stdio: 'pipe',
         encoding: 'utf-8'
       });
     } catch (error) {
-      console.warn(`Warning: ruff formatting failed for ${dir}. You may need to install ruff or run it manually.`);
+      console.warn(`Warning: ruff check failed for ${dir}. You may need to install ruff or run it manually.`);
     }
 
-    // Run black formatter
+    // Run ruff format (formatting — matches CI's `ruff format --check`)
     try {
-      execSync(`uv run black "${dir}"`, {
+      execFileSync("uv", ["run", "ruff", "format", dir], {
         cwd: projectRoot,
         stdio: 'pipe',
         encoding: 'utf-8'
       });
     } catch (error) {
-      console.warn(`Warning: black formatting failed for ${dir}. You may need to install black or run it manually.`);
+      console.warn(`Warning: ruff format failed for ${dir}. You may need to install ruff or run it manually.`);
     }
   }
 }
@@ -174,33 +189,111 @@ function findPythonProjectRoot(startDir: string): string | undefined {
 
 /**
  * Build context for rendering a single Python class.
+ * Resolves factories and coercions via the expression IR when registry/visitor provided.
  */
-function buildClassContext(node: TypeNode): PythonClassContext {
+function buildClassContext(
+  node: TypeNode,
+  registry?: TypeRegistry,
+  visitor?: ExprVisitor,
+): PythonClassContext {
+  // Pre-compute safe factory method names to avoid field/classmethod collisions.
+  const fieldNames = new Set(node.properties.map(p => toSnakeCase(p.name)));
+  const factoryNameMap: Record<string, string> = {};
+  for (const factory of node.factories) {
+    const snakeName = toSnakeCase(factory.name);
+    factoryNameMap[factory.name] = fieldNames.has(snakeName) ? `create_${snakeName}` : snakeName;
+  }
+
+  // Resolve factories via expression IR (when registry+visitor available)
+  const factoryTypeRefs: string[] = [];
+  const renderedFactories = (registry && visitor) ? (node.factories || []).map(f => {
+    const expr = resolveFactoryExpr(f.sets, f.params, node, registry);
+    for (const ref of collectExprTypeRefs(expr)) {
+      factoryTypeRefs.push(ref.name);
+    }
+    return {
+      name: f.name,
+      safeName: factoryNameMap[f.name],
+      params: f.params,
+      body: visitor.visitExpr(expr),
+    };
+  }) : [];
+
+  // Resolve coercions via expression IR
+  const renderedCoercions = (registry && visitor) ? (node.coercions || []).map(c => {
+    const expr = resolveCoerceExpr(c.expansion, c.scalar, node, registry, "data");
+    return {
+      scalar: pythonTypeMapper[c.scalar] || c.scalar,
+      expression: renderObjectLiteral(expr, visitor, "py"),
+    };
+  }) : [];
+
+  // Keep factory-referenced types for file-level import resolution
+  // Don't merge into class imports — the file template handles imports
+  const baseImports = getUniqueImportTypes(node);
+
   return {
     node,
     typeMapper: pythonTypeMapper,
-    alternates: prepareAlternates(node),
+    coercions: prepareCoercions(node),
     polymorphicTypes: node.retrievePolymorphicTypes(),
-    imports: getUniqueImportTypes(node),
+    imports: baseImports,
     collectionTypes: getCollectionTypes(node),
-    shorthandProperty: getShorthandProperty(node),
+    coercionProperty: getCoercionProperty(node),
+    factoryNameMap,
+    renderedFactories,
+    renderedCoercions,
+    factoryTypeRefs,
   };
 }
 
 /**
  * Build context for rendering a Python file with a base type and its children.
  */
-function buildFileContext(node: TypeNode): PythonFileContext {
-  // Build class contexts for this node and all its children
+function buildFileContext(
+  node: TypeNode,
+  registry: TypeRegistry,
+  visitor: ExprVisitor,
+): PythonFileContext {
   const classes: PythonClassContext[] = [
-    buildClassContext(node),
-    ...node.childTypes.map(ct => buildClassContext(ct))
+    buildClassContext(node, registry, visitor),
+    ...node.childTypes.map(ct => buildClassContext(ct, registry, visitor))
   ];
 
+  // Build grouped imports: module → set of type names to import from that module
+  // This handles both base types (module == type) and child types (module == parent type)
+  const childTypeNames = new Set([node.typeName.name, ...node.childTypes.map(ct => ct.typeName.name)]);
+  const importMap = new Map<string, Set<string>>();
+
+  const addImport = (typeName: string) => {
+    if (childTypeNames.has(typeName)) return; // Skip types defined in this file
+    // Find which module this type lives in
+    const refNode = registry.get(typeName);
+    const module = refNode?.base ? refNode.base.name : typeName;
+    if (!importMap.has(module)) importMap.set(module, new Set());
+    importMap.get(module)!.add(typeName);
+  };
+
+  // Property-based imports (base types referenced by properties)
+  for (const name of getUniqueImportTypes(node)) {
+    addImport(name);
+  }
+
+  // Factory-referenced imports (may include child types like TextPart)
+  for (const cls of classes) {
+    for (const ref of cls.factoryTypeRefs) {
+      addImport(ref);
+    }
+  }
+
+  const imports = Array.from(importMap.entries())
+    .map(([module, names]) => ({ module, names: Array.from(names).sort() }))
+    .sort((a, b) => a.module.localeCompare(b.module));
+
   return {
     containsAbstract: node.isAbstract || node.childTypes.some(c => c.isAbstract),
     typings: ["Any", "Callable", "Optional"],
-    imports: getUniqueImportTypes(node),
+    imports,
     classes,
     typeMapper: pythonTypeMapper,
   };
@@ -219,8 +312,10 @@ function buildInitContext(nodes: TypeNode[]): PythonInitContext {
 /**
  * Build context for rendering a test file using the standardized shared helper.
  */
-function buildTestContext(node: TypeNode, packageName: string): BaseTestContext {
-  return buildBaseTestContext(node, packageName, pythonTestOptions);
+function buildTestContext(node: TypeNode, packageName: string): BaseTestContext & { classCtx: PythonClassContext } {
+  const base = buildBaseTestContext(node, packageName, pythonTestOptions);
+  const classCtx = buildClassContext(node);
+  return { ...base, classCtx };
 }
 
 /**
@@ -234,15 +329,15 @@ function buildLoadContextContext(packageName?: string): PythonLoadContextContext
 }
 
 /**
- * Prepare alternate representations for template rendering.
- * Converts alternates to Python-specific format with JSON stringification.
+ * Prepare coercion representations for template rendering.
+ * Converts coercions to Python-specific format with JSON stringification.
  */
-function prepareAlternates(node: TypeNode): Array<{ scalar: string; alternate: string }> {
-  if (!node.alternates || node.alternates.length === 0) {
+function prepareCoercions(node: TypeNode): Array<{ scalar: string; alternate: string }> {
+  if (!node.coercions || node.coercions.length === 0) {
     return [];
   }
 
-  return node.alternates.map(alt => ({
+  return node.coercions.map(alt => ({
     scalar: pythonTypeMapper[alt.scalar],
     alternate: JSON.stringify(alt.expansion, null, '')
       .replaceAll('\n', '')
@@ -251,16 +346,16 @@ function prepareAlternates(node: TypeNode): Array<{ scalar: string; alternate: s
 }
 
 /**
- * Get the shorthand property name from alternates.
- * The shorthand property is the one that receives "{value}" in the expansion.
+ * Get the coercion property name from coercions.
+ * The coercion property is the one that receives "{value}" in the expansion.
  */
-function getShorthandProperty(node: TypeNode): string | null {
-  if (!node.alternates || node.alternates.length === 0) {
+function getCoercionProperty(node: TypeNode): string | null {
+  if (!node.coercions || node.coercions.length === 0) {
     return null;
   }
 
   // Look for a property that has "{value}" as its expansion value
-  for (const alt of node.alternates) {
+  for (const alt of node.coercions) {
     for (const [key, value] of Object.entries(alt.expansion)) {
       if (value === "{value}") {
         return key;
@@ -273,12 +368,13 @@ function getShorthandProperty(node: TypeNode): string | null {
 /**
  * Get collection properties with their nested type info for load_* methods.
  */
-function getCollectionTypes(node: TypeNode): Array<{ prop: PropertyNode; type: string[] }> {
+function getCollectionTypes(node: TypeNode): Array<{ prop: PropertyNode; type: string[]; hasNameProperty: boolean }> {
   return node.properties
     .filter(p => p.isCollection && !p.isScalar && !p.isDict)
     .map(p => ({
       prop: p,
       type: p.type?.properties.filter(t => t.name !== "name").map(t => t.name) || [],
+      hasNameProperty: p.type?.properties.some(t => t.name === "name") || false,
     }));
 }
 
diff --git a/schema/emitter/src/languages/python/emitter.ts b/schema/emitter/src/languages/python/emitter.ts
new file mode 100644
index 00000000..1b7fc999
--- /dev/null
+++ b/schema/emitter/src/languages/python/emitter.ts
@@ -0,0 +1,907 @@
+/**
+ * Python code emitter — Declaration IR → Python source code.
+ *
+ * Replaces `file.py.njk` + `_macros.njk` (~619 lines of Nunjucks templates)
+ * with a typed TypeScript function that walks the FileDecl tree.
+ *
+ * The emitter produces correctly-formatted Python 3.11+ code using modern
+ * `X | None` union syntax. Output should be byte-identical to the template
+ * output after ruff+black formatting.
+ *
+ * Structural blocks emitted (in order):
+ *   1. Header comment (auto-generated warning)
+ *   2. Imports (abc, dataclasses, typing, context, local types)
+ *   3. For each type in the file:
+ *      a. @dataclass class definition with docstring
+ *      b. _shorthand_property ClassVar
+ *      c. Field declarations with type annotations + defaults
+ *      d. load() static method
+ *      e. Collection helpers (load_X / save_X)
+ *      f. Polymorphic dispatch (load_<discriminator>)
+ *      g. save() instance method
+ *      h. to_yaml() and to_json() methods
+ *      i. Factory classmethods
+ *      j. Method stubs (as comments)
+ */
+
+import {
+  FileDecl,
+  TypeDecl,
+  FieldDecl,
+  LoadAssignment,
+  SaveAssignment,
+  CollectionHelperDecl,
+  PolymorphicDispatchDecl,
+  FactoryDecl,
+  CoercionDecl,
+  PropertyCategory,
+  WireFieldMapping,
+} from "../../ir/declarations.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+
+/**
+ * Type mapping from TypeSpec scalar types to Python types.
+ */
+const TYPE_MAP: Record<string, string> = {
+  "string": "str",
+  "number": "float",
+  "array": "list",
+  "object": "dict",
+  "boolean": "bool",
+  "int64": "int",
+  "int32": "int",
+  "float64": "float",
+  "float32": "float",
+  "integer": "int",
+  "float": "float",
+  "numeric": "float",
+  "any": "Any",
+  "dictionary": "dict[str, Any]",
+};
+
+function paramType(typeStr: string): string {
+  if (typeStr === "string") return "str";
+  if (typeStr === "boolean") return "bool";
+  if (typeStr === "integer" || typeStr === "int32" || typeStr === "int64") return "int";
+  if (typeStr === "float" || typeStr === "float64" || typeStr === "float32") return "float";
+  return "Any";
+}
+
+function returnType(typeStr: string): string {
+  if (typeStr === "string") return "str";
+  if (typeStr === "boolean") return "bool";
+  if (typeStr === "integer" || typeStr === "int32" || typeStr === "int64") return "int";
+  if (typeStr === "float" || typeStr === "float64" || typeStr === "float32") return "float";
+  return typeStr;
+}
+
+// ============================================================================
+// Main entry point
+// ============================================================================
+
+/**
+ * Emit a complete Python file from a FileDecl.
+ */
+export function emitPythonFile(decl: FileDecl, visitor: ExprVisitor): string {
+  const lines: string[] = [];
+
+  // 1. Header
+  lines.push("##########################################");
+  lines.push("# WARNING: This is an auto-generated file.");
+  lines.push("# DO NOT EDIT THIS FILE DIRECTLY");
+  lines.push("# ANY EDITS WILL BE LOST");
+  lines.push("##########################################");
+  lines.push("");
+
+  // 2. Imports — sorted alphabetically as ruff/isort would
+  // Collect all import lines, then sort them
+  const stdlibImports: string[] = [];
+  const localImports: string[] = [];
+  const hasProtocol = decl.types.some(t => t.isProtocol);
+  const hasNonProtocol = decl.types.some(t => !t.isProtocol);
+  const hasMethodHelpers = decl.types.some(t => !t.isProtocol && t.methods.length > 0);
+
+  if (decl.containsAbstract) {
+    stdlibImports.push("from abc import ABC");
+  }
+  if (hasNonProtocol) {
+    stdlibImports.push("from dataclasses import dataclass, field");
+  }
+  const typingImports = ["Any"];
+  if (hasNonProtocol) typingImports.push("ClassVar");
+  if (hasProtocol || hasMethodHelpers) typingImports.push("Protocol", "runtime_checkable");
+  typingImports.sort();
+  stdlibImports.push(`from typing import ${typingImports.join(", ")}`);
+
+  // Context import + local type imports — sorted alphabetically
+  if (hasNonProtocol) {
+    localImports.push("from ._context import LoadContext, SaveContext");
+  }
+  for (const imp of decl.imports) {
+    localImports.push(`from ._${imp.module} import ${imp.names.join(", ")}`);
+  }
+  localImports.sort();
+
+  for (const line of stdlibImports) {
+    lines.push(line);
+  }
+  lines.push("");
+  for (const line of localImports) {
+    lines.push(line);
+  }
+
+  // 3. Emit each type
+  for (const type of decl.types) {
+    lines.push("");
+    lines.push("");
+    emitType(type, lines, visitor);
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+// ============================================================================
+// Type emission
+// ============================================================================
+
+function emitType(type: TypeDecl, lines: string[], visitor: ExprVisitor): void {
+  const name = type.typeName.name;
+
+  // Protocol types → emit as Protocol class with method signatures
+  if (type.isProtocol) {
+    emitProtocolClass(type, lines);
+    return;
+  }
+
+  // Class definition
+  lines.push("@dataclass");
+  const bases: string[] = [];
+  if (type.base) bases.push(type.base.name);
+  if (type.isAbstract) bases.push("ABC");
+  const baseSuffix = bases.length > 0 ? `(${bases.join(", ")})` : "";
+  lines.push(`class ${name}${baseSuffix}:`);
+
+  // Docstring
+  emitDocstring(type, lines);
+
+  // _shorthand_property ClassVar
+  lines.push("");
+  const shorthand = type.coercionProperty ? `"${type.coercionProperty}"` : "None";
+  lines.push(`    _shorthand_property: ClassVar[str | None] = ${shorthand}`);
+
+  // Field declarations (blank line between _shorthand and first field)
+  lines.push("");
+  for (const field of type.fields) {
+    lines.push(`    ${toSnakeCase(field.name)}: ${pythonTypeAnnotation(field)}${pythonDefaultValue(field)}`);
+  }
+
+  // load() method
+  lines.push("");
+  emitLoadMethod(type, lines);
+
+  // Collection helpers (between load and polymorphic dispatch)
+  for (const helper of type.collectionHelpers) {
+    emitCollectionLoadHelper(name, helper, lines);
+    lines.push("");
+    emitCollectionSaveHelper(name, helper, lines);
+  }
+
+  // Polymorphic dispatch
+  if (type.polymorphicDispatch) {
+    lines.push("");
+    lines.push("");
+    emitPolymorphicDispatch(name, type.polymorphicDispatch, type.isAbstract, lines);
+  }
+
+  // save() method
+  lines.push("");
+  emitSaveMethod(type, lines);
+
+  // to_wire() method (only when wire mappings exist)
+  if (type.wire) {
+    emitToWireMethod(type, lines);
+  }
+
+  // to_yaml() method
+  emitToYaml(name, lines);
+
+  // to_json() method
+  emitToJson(name, lines);
+
+  // Factory methods
+  if (type.factories.length > 0) {
+    const fieldNames = new Set(type.fields.map(f => f.name));
+    lines.push("");
+    for (const factory of type.factories) {
+      emitFactory(name, factory, visitor, fieldNames, lines);
+      lines.push("");
+    }
+  }
+
+  lines.push("");
+
+  // Method stubs — emit as a sibling Protocol class outside the dataclass
+  if (type.methods.length > 0) {
+    emitMethodHelpersProtocol(type, lines);
+  }
+}
+
+/**
+ * Emit a typing.Protocol class named `<TypeName>Helpers` that declares the
+ * `@method` contract for a concrete type. The generated dataclass does NOT
+ * satisfy this Protocol on its own — runtime code must provide an
+ * implementation (either by attaching methods to the class or by providing
+ * a wrapper type). Using `@runtime_checkable` allows isinstance() checks.
+ */
+function emitMethodHelpersProtocol(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+  lines.push("");
+  lines.push("");
+  lines.push("@runtime_checkable");
+  lines.push(`class ${name}Helpers(Protocol):`);
+  lines.push(`    """Helper contract for ${name}.`);
+  lines.push("");
+  lines.push(`    Runtime implementations must provide these methods on every ${name}`);
+  lines.push("    instance (either by attaching them to the generated class or by wrapping it).");
+  lines.push("    The type checker can verify conformance by annotating against this Protocol");
+  lines.push(`    or by calling isinstance(instance, ${name}Helpers) at runtime.`);
+  lines.push(`    """`);
+  for (const m of type.methods) {
+    const params = Object.entries(m.params)
+      .map(([pName, pType]) => `${toSnakeCase(pName)}: ${protocolType(pType)}`)
+      .join(", ");
+    const paramList = params ? `, ${params}` : "";
+    const ret = protocolType(m.returns);
+    const snakeName = toSnakeCase(m.name);
+    // Zero-param, non-verb methods are emitted as @property — idiomatic Python
+    // for accessor-style helpers (matches the C# emitter's heuristic).
+    const isProperty = Object.keys(m.params).length === 0 && !isMethodStyle(m.name);
+    lines.push("");
+    if (isProperty) {
+      lines.push("    @property");
+    }
+    lines.push(`    def ${snakeName}(self${paramList}) -> ${ret}:`);
+    if (m.description) {
+      lines.push(`        """${m.description}"""`);
+    }
+    lines.push("        ...");
+  }
+}
+
+/**
+ * Verbs that indicate an action — zero-param @methods whose name starts with
+ * one of these are emitted as regular Python methods. Everything else becomes
+ * a ``@property``. Mirrors the C# emitter's heuristic so both runtimes expose
+ * ``message.text`` as a property and ``message.to_text_content()`` as a method.
+ */
+const PY_METHOD_VERB_PREFIXES = [
+  "to", "get", "set", "fetch", "compute", "make", "build", "create",
+  "load", "save", "convert", "parse", "format", "render", "serialize",
+  "deserialize", "find", "calculate", "invoke", "execute", "run",
+];
+
+function isMethodStyle(name: string): boolean {
+  const lower = name.toLowerCase();
+  for (const prefix of PY_METHOD_VERB_PREFIXES) {
+    if (lower === prefix) return true;
+    if (lower.startsWith(prefix) && name.length > prefix.length) {
+      const next = name[prefix.length];
+      if (next === next.toUpperCase() && next !== next.toLowerCase()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// ============================================================================
+// Protocol class emission
+// ============================================================================
+
+/** Map a protocol type string to a Python type annotation. */
+function protocolType(typeStr: string): string {
+  // Handle nullable types
+  if (typeStr.endsWith("?")) {
+    const inner = typeStr.slice(0, -1);
+    return `${protocolType(inner)} | None`;
+  }
+  // Handle array types
+  if (typeStr.endsWith("[]")) {
+    const inner = typeStr.slice(0, -2);
+    return `list[${protocolType(inner)}]`;
+  }
+  // Handle Record/dict types
+  if (typeStr === "Record<unknown>" || typeStr === "dictionary") return "dict[str, Any]";
+  if (typeStr === "unknown" || typeStr === "any") return "Any";
+  // Scalar types
+  const mapped = TYPE_MAP[typeStr];
+  if (mapped) return mapped;
+  return typeStr;
+}
+
+/**
+ * Emit a Python Protocol class for a protocol type.
+ * Uses typing.Protocol for structural subtyping.
+ */
+function emitProtocolClass(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+
+  lines.push("@runtime_checkable");
+  lines.push(`class ${name}(Protocol):`);
+
+  // Docstring
+  if (type.description) {
+    const descLines = type.description.split("\n");
+    lines.push(`    """${descLines[0]}`);
+    for (let i = 1; i < descLines.length; i++) {
+      lines.push(`    ${descLines[i]}`);
+    }
+    lines.push(`    """`);
+  }
+
+  if (type.methods.length === 0) {
+    lines.push("    ...");
+    return;
+  }
+
+  for (const method of type.methods) {
+    const params = Object.entries(method.params)
+      .map(([pName, pType]) => `${toSnakeCase(pName)}: ${protocolType(pType)}`)
+      .join(", ");
+    const ret = protocolType(method.returns);
+
+    // Sync method
+    lines.push("");
+    if (method.description) {
+      lines.push(`    def ${toSnakeCase(method.name)}(self, ${params}) -> ${ret}:`);
+      lines.push(`        """${method.description}"""`);
+      if (method.optional) {
+        lines.push("        return None");
+      } else {
+        lines.push("        ...");
+      }
+    } else {
+      if (method.optional) {
+        lines.push(`    def ${toSnakeCase(method.name)}(self, ${params}) -> ${ret}:`);
+        lines.push("        return None");
+      } else {
+        lines.push(`    def ${toSnakeCase(method.name)}(self, ${params}) -> ${ret}: ...`);
+      }
+    }
+
+    // Async variant (skip for sync-only methods)
+    if (!method.sync) {
+      lines.push("");
+      if (method.description) {
+        lines.push(`    async def ${toSnakeCase(method.name)}_async(self, ${params}) -> ${ret}:`);
+        lines.push(`        """${method.description} (async variant)"""`);
+        if (method.optional) {
+          lines.push("        return None");
+        } else {
+          lines.push("        ...");
+        }
+      } else {
+        if (method.optional) {
+          lines.push(`    async def ${toSnakeCase(method.name)}_async(self, ${params}) -> ${ret}:`);
+          lines.push("        return None");
+        } else {
+          lines.push(`    async def ${toSnakeCase(method.name)}_async(self, ${params}) -> ${ret}: ...`);
+        }
+      }
+    }
+  }
+
+  lines.push("");
+}
+
+// ============================================================================
+// Docstring
+// ============================================================================
+
+function emitDocstring(type: TypeDecl, lines: string[]): void {
+  const descLines = type.description.split("\n");
+  lines.push(`    """${descLines[0]}`);
+  for (let i = 1; i < descLines.length; i++) {
+    lines.push(`    ${descLines[i]}`);
+  }
+
+  if (type.fields.length > 0) {
+    lines.push("    ");
+    lines.push("    Attributes");
+    lines.push("    ----------");
+    for (const f of type.fields) {
+      lines.push(`    ${toSnakeCase(f.name)} : ${pythonDocstringType(f)}`);
+      lines.push(`        ${f.description}`);
+    }
+  }
+  lines.push(`    """`);
+}
+
+// ============================================================================
+// Type annotations — uses modern X | None syntax
+// ============================================================================
+
+function pythonTypeAnnotation(f: FieldDecl): string {
+  const cat = f.category;
+  switch (cat.kind) {
+    case "dict":
+      return f.isOptional ? "dict[str, Any] | None" : "dict[str, Any]";
+    case "collection_scalar":
+      return `list[${TYPE_MAP[cat.scalarType] || "Any"}]`;
+    case "collection_complex":
+      return `list[${cat.typeName}]`;
+    case "scalar": {
+      const pyType = TYPE_MAP[cat.scalarType] || "Any";
+      return f.isOptional ? `${pyType} | None` : pyType;
+    }
+    case "complex":
+      return f.isOptional ? `${cat.typeName} | None` : cat.typeName;
+  }
+}
+
+function pythonDocstringType(f: FieldDecl): string {
+  const cat = f.category;
+  let baseType: string;
+  switch (cat.kind) {
+    case "dict":
+      baseType = "dict[str, Any]";
+      break;
+    case "collection_scalar":
+      baseType = `list[${TYPE_MAP[cat.scalarType] || "Any"}]`;
+      break;
+    case "collection_complex":
+      baseType = `list[${cat.typeName}]`;
+      break;
+    case "scalar":
+      baseType = TYPE_MAP[cat.scalarType] || "Any";
+      break;
+    case "complex":
+      baseType = cat.typeName;
+      break;
+  }
+  if (f.isOptional) return `Optional[${baseType}]`;
+  return baseType;
+}
+
+// ============================================================================
+// Default values
+// ============================================================================
+
+function pythonDefaultValue(f: FieldDecl): string {
+  const cat = f.category;
+
+  if (cat.kind === "collection_scalar" || cat.kind === "collection_complex") {
+    return " = field(default_factory=list)";
+  }
+
+  if (f.isOptional) {
+    return " = None";
+  }
+
+  if (cat.kind === "scalar") {
+    const t = cat.scalarType;
+    if (t === "boolean") {
+      return ` = field(default=${f.defaultValue ? "True" : "False"})`;
+    }
+    if (t === "string") {
+      return ` = field(default="${f.defaultValue ?? ""}")`;
+    }
+    if (t === "number" || t === "numeric" || t === "float64" || t === "float32" || t === "float") {
+      return ` = field(default=${f.defaultValue ?? "0.0"})`;
+    }
+    if (t === "int64" || t === "int32" || t === "integer") {
+      return ` = field(default=${f.defaultValue ?? "0"})`;
+    }
+    if (t === "dictionary") {
+      return " = field(default_factory=dict)";
+    }
+    return ` = field(default=${f.defaultValue ?? "None"})`;
+  }
+
+  if (cat.kind === "dict") {
+    return " = field(default_factory=dict)";
+  }
+
+  if (cat.kind === "complex") {
+    return ` = field(default_factory=${f.typeName.name})`;
+  }
+
+  return " = None";
+}
+
+// ============================================================================
+// load() method
+// ============================================================================
+
+function emitLoadMethod(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+
+  lines.push("    @staticmethod");
+  lines.push(`    def load(data: Any, context: LoadContext | None = None) -> "${name}":`);
+  lines.push(`        """Load a ${name} instance.`);
+  lines.push("        Args:");
+  lines.push("            data (Any): The data to load the instance from.");
+  lines.push("            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.");
+  lines.push("        Returns:");
+  lines.push(`            ${name}: The loaded ${name} instance.`);
+  lines.push("");
+  lines.push(`        """`);
+  lines.push("");
+  lines.push("        if context is not None:");
+  lines.push("            data = context.process_input(data)");
+
+  // Coercion checks — direct property setting instead of dict construction
+  if (type.load.coercions.length > 0) {
+    lines.push("        ");
+    lines.push("        # handle alternate representations");
+    for (const c of type.load.coercions) {
+      emitCoercionBranch(name, c, type, lines);
+    }
+  }
+
+  lines.push("        ");
+  lines.push(`        if not isinstance(data, dict):`);
+  lines.push(`            raise ValueError(f"Invalid data for ${name}: {data}")`);
+
+  // Create instance (polymorphic dispatch or direct)
+  if (type.load.hasPolymorphicDispatch && type.polymorphicDispatch) {
+    const discSnake = toSnakeCase(type.polymorphicDispatch.discriminatorField);
+    lines.push("");
+    lines.push(`        # load polymorphic ${name} instance`);
+    lines.push(`        instance = ${name}.load_${discSnake}(data, context)`);
+  } else {
+    lines.push("");
+    lines.push(`        # create new instance`);
+    lines.push(`        instance = ${name}()`);
+  }
+
+  // Blank line(s) after instance creation
+  lines.push("");
+  if (type.load.hasPolymorphicDispatch) {
+    lines.push("");
+  }
+
+  // Per-property assignments
+  for (const a of type.load.assignments) {
+    lines.push(`        if data is not None and "${a.sourceName}" in data:`);
+    lines.push(`            ${emitLoadAssignment(a)}`);
+  }
+
+  // Context post-processing
+  lines.push("        if context is not None:");
+  lines.push("            instance = context.process_output(instance)");
+  lines.push("        return instance");
+  lines.push("");
+  lines.push("");
+}
+
+function emitLoadAssignment(a: LoadAssignment): string {
+  const snake = toSnakeCase(a.fieldName);
+  const cat = a.category;
+  switch (cat.kind) {
+    case "scalar":
+    case "dict":
+    case "collection_scalar":
+      return `instance.${snake} = data["${a.sourceName}"]`;
+    case "collection_complex":
+      return `instance.${snake} = ${a.parentTypeName}.load_${snake}(data["${a.sourceName}"], context)`;
+    case "complex":
+      return `instance.${snake} = ${cat.typeName}.load(data["${a.sourceName}"], context)`;
+  }
+}
+
+/**
+ * Emit a single coercion branch — direct property setting with early return.
+ *
+ * For types where the coercion involves a dynamic discriminator with child
+ * variants, falls back to calling the dispatch method.
+ */
+function emitCoercionBranch(
+  typeName: string,
+  c: CoercionDecl,
+  type: TypeDecl,
+  lines: string[],
+): void {
+  const pyScalar = TYPE_MAP[c.scalarType] || c.scalarType;
+  lines.push(`        if isinstance(data, ${pyScalar}):`);
+
+  if (c.needsDispatch && type.polymorphicDispatch) {
+    // Dynamic discriminator — must go through dispatch
+    const discSnake = toSnakeCase(type.polymorphicDispatch.discriminatorField);
+    // Build a minimal dict for the dispatch method
+    const dictFields = c.assignments.map(a => {
+      const val = a.isInput ? "data" : `"${a.literalValue}"`;
+      return `"${a.fieldName}": ${val}`;
+    });
+    lines.push(`            return ${typeName}.load_${discSnake}({${dictFields.join(", ")}}, context)`);
+  } else {
+    // Direct property setting — no intermediate dict
+    lines.push(`            instance = ${typeName}()`);
+    for (const a of c.assignments) {
+      const snake = toSnakeCase(a.fieldName);
+      if (a.isInput) {
+        lines.push(`            instance.${snake} = data`);
+      } else {
+        lines.push(`            instance.${snake} = "${a.literalValue}"`);
+      }
+    }
+    lines.push("            if context is not None:");
+    lines.push("                instance = context.process_output(instance)");
+    lines.push("            return instance");
+  }
+}
+
+// ============================================================================
+// Collection helpers (load_X / save_X)
+// ============================================================================
+
+function emitCollectionLoadHelper(parentName: string, helper: CollectionHelperDecl, lines: string[]): void {
+  const snake = toSnakeCase(helper.propertyName);
+  const elemName = helper.elementTypeName.name;
+  const firstInnerField = helper.innerFields[0] || "kind";
+
+  lines.push("");
+  lines.push("    @staticmethod");
+  lines.push(`    def load_${snake}(data: dict | list, context: LoadContext | None) -> list[${elemName}]:`);
+  lines.push("        if isinstance(data, dict):");
+  lines.push(`            # convert simple named ${helper.propertyName} to list of ${elemName}`);
+  lines.push("            result = []");
+  lines.push("            for k, v in data.items():");
+  lines.push("                if isinstance(v, dict):");
+  lines.push("                    # value is an object, spread its properties");
+  lines.push(`                    result.append({"name": k, **v})`);
+  lines.push("                else:");
+  lines.push("                    # value is a scalar, use it as the primary property");
+  lines.push(`                    result.append({"name": k, "${firstInnerField}": v})`);
+  lines.push("            data = result");
+  lines.push(`        return [${elemName}.load(item, context) for item in data]`);
+}
+
+function emitCollectionSaveHelper(parentName: string, helper: CollectionHelperDecl, lines: string[]): void {
+  const snake = toSnakeCase(helper.propertyName);
+  const elemName = helper.elementTypeName.name;
+
+  lines.push("    @staticmethod");
+  lines.push(`    def save_${snake}(items: list[${elemName}], context: SaveContext | None) -> dict[str, Any] | list[dict[str, Any]]:`);
+  lines.push("        if context is None:");
+  lines.push("            context = SaveContext()");
+
+  if (helper.hasNameProperty) {
+    lines.push("");
+    lines.push('        if context.collection_format == "array":');
+    lines.push("            return [item.save(context) for item in items]");
+    lines.push("");
+    lines.push("        # Object format: use name as key");
+    lines.push("        result: dict[str, Any] = {}");
+    lines.push("        for item in items:");
+    lines.push("            item_data = item.save(context)");
+    lines.push('            name = item_data.pop("name", None)');
+    lines.push("            if name:");
+    lines.push("                # Check if we can use shorthand (only primary property set)");
+    lines.push("                if context.use_shorthand and hasattr(item, '_shorthand_property'):");
+    lines.push("                    shorthand_prop = item._shorthand_property");
+    lines.push("                    if shorthand_prop and len(item_data) == 1 and shorthand_prop in item_data:");
+    lines.push("                        result[name] = item_data[shorthand_prop]");
+    lines.push("                        continue");
+    lines.push("                result[name] = item_data");
+    lines.push("            else:");
+    lines.push('                # No name, fall back to array format for this item');
+    lines.push('                if "_unnamed" not in result:');
+    lines.push('                    result["_unnamed"] = []');
+    lines.push('                result["_unnamed"].append(item_data)');
+    lines.push("        return result");
+  } else {
+    lines.push("");
+    lines.push("        # This type doesn't have a 'name' property, so always use array format");
+    lines.push("        return [item.save(context) for item in items]");
+  }
+}
+
+// ============================================================================
+// Polymorphic dispatch
+// ============================================================================
+
+function emitPolymorphicDispatch(
+  parentName: string,
+  dispatch: PolymorphicDispatchDecl,
+  isAbstract: boolean,
+  lines: string[],
+): void {
+  const discSnake = toSnakeCase(dispatch.discriminatorField);
+  lines.push("    @staticmethod");
+  lines.push(`    def load_${discSnake}(data: dict, context: LoadContext | None) -> "${parentName}":`);
+  lines.push(`        # load polymorphic ${parentName} instance`);
+  lines.push(`        if data is not None and "${dispatch.discriminatorField}" in data:`);
+  lines.push(`            discriminator_value = str(data["${dispatch.discriminatorField}"]).lower()`);
+
+  for (let i = 0; i < dispatch.variants.length; i++) {
+    const v = dispatch.variants[i];
+    const keyword = i === 0 ? "if" : "elif";
+    lines.push(`            ${keyword} discriminator_value == "${v.value}":`);
+    lines.push(`                return ${v.typeName.name}.load(data, context)`);
+  }
+
+  // Default handling — matches template whitespace exactly
+  if (dispatch.defaultVariant) {
+    lines.push("");
+    lines.push("            else:");
+    if (dispatch.defaultVariant.isSelfReference) {
+      lines.push(`                # create new instance (stop recursion)`);
+      lines.push(`                return ${parentName}()`);
+    } else {
+      lines.push("");
+      lines.push(`                # load default instance`);
+      lines.push(`                return ${dispatch.defaultVariant.typeName.name}.load(data, context)`);
+    }
+  } else {
+    lines.push("");
+    lines.push("            else:");
+    lines.push(`                raise ValueError(f"Unknown ${parentName} discriminator value: {discriminator_value}")`);
+  }
+
+  lines.push("        else:");
+  if (isAbstract) {
+    lines.push("");
+    lines.push(`            raise ValueError("Missing ${parentName} discriminator property: '${dispatch.discriminatorField}'")`);
+  } else {
+    lines.push(`            # create new instance`);
+    lines.push(`            return ${parentName}()`);
+  }
+  lines.push("");
+}
+
+// ============================================================================
+// save() method
+// ============================================================================
+
+function emitSaveMethod(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+
+  lines.push(`    def save(self, context: SaveContext | None = None) -> dict[str, Any]:`);
+  lines.push(`        """Save the ${name} instance to a dictionary.`);
+  lines.push("        Args:");
+  lines.push("            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.");
+  lines.push("        Returns:");
+  lines.push("            dict[str, Any]: The dictionary representation of this instance.");
+  lines.push("");
+  lines.push(`        """`);
+  lines.push("        obj = self");
+  lines.push("        if context is not None:");
+  lines.push("            obj = context.process_object(obj)");
+  lines.push("");
+
+  if (type.save.hasBase) {
+    lines.push("");
+    lines.push("        # Start with parent class properties");
+    lines.push("        result = super().save(context)");
+    lines.push("");
+  } else {
+    lines.push("");
+    lines.push("        result: dict[str, Any] = {}");
+  }
+
+  // Per-property save assignments
+  lines.push("");
+  for (const a of type.save.assignments) {
+    const snake = toSnakeCase(a.fieldName);
+    lines.push(`        if obj.${snake} is not None:`);
+    lines.push(`            ${emitSaveAssignment(a)}`);
+  }
+
+  // Context post-processing (only for root types without base)
+  if (!type.save.hasBase) {
+    lines.push("");
+    lines.push("        if context is not None:");
+    lines.push("            result = context.process_dict(result)");
+  }
+  lines.push("        return result");
+  lines.push("");
+}
+
+function emitSaveAssignment(a: SaveAssignment): string {
+  const snake = toSnakeCase(a.fieldName);
+  const cat = a.category;
+  switch (cat.kind) {
+    case "scalar":
+    case "dict":
+    case "collection_scalar":
+      return `result["${a.targetName}"] = obj.${snake}`;
+    case "collection_complex":
+      return `result["${a.targetName}"] = ${a.parentTypeName}.save_${snake}(obj.${snake}, context)`;
+    case "complex":
+      return `result["${a.targetName}"] = obj.${snake}.save(context)`;
+  }
+}
+
+// ============================================================================
+// to_wire() method
+// ============================================================================
+
+function emitToWireMethod(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+  const wire = type.wire!;
+
+  lines.push(`    def to_wire(self, provider: str) -> dict[str, Any]:`);
+  lines.push(`        """Convert to provider-specific wire format.`);
+  lines.push("        Args:");
+  lines.push("            provider (str): The provider to convert to (e.g., \"openai\", \"anthropic\").");
+  lines.push("        Returns:");
+  lines.push("            dict[str, Any]: The wire-format dictionary with provider-specific field names.");
+  lines.push("");
+  lines.push(`        """`);
+  lines.push("        data = self.save()");
+  lines.push("        result: dict[str, Any] = {}");
+
+  // Build the wire_map literal from the IR mappings
+  lines.push("        wire_map: dict[str, dict[str, str]] = {");
+  for (const mapping of wire.mappings) {
+    const entries = Object.entries(mapping.wireNames)
+      .map(([provider, wireName]) => `"${provider}": "${wireName}"`)
+      .join(", ");
+    lines.push(`            "${mapping.fieldName}": {${entries}},`);
+  }
+  lines.push("        }");
+
+  lines.push("        for key, value in data.items():");
+  lines.push("            mapping = wire_map.get(key)");
+  lines.push("            if mapping is not None and provider in mapping:");
+  lines.push("                result[mapping[provider]] = value");
+  lines.push("        return result");
+  lines.push("");
+}
+
+// ============================================================================
+// to_yaml() / to_json() methods
+// ============================================================================
+
+function emitToYaml(name: string, lines: string[]): void {
+  lines.push(`    def to_yaml(self, context: SaveContext | None = None) -> str:`);
+  lines.push(`        """Convert the ${name} instance to a YAML string.`);
+  lines.push("        Args:");
+  lines.push("            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.");
+  lines.push("        Returns:");
+  lines.push("            str: The YAML string representation of this instance.");
+  lines.push("");
+  lines.push(`        """`);
+  lines.push("        if context is None:");
+  lines.push("            context = SaveContext()");
+  lines.push("        return context.to_yaml(self.save(context))");
+  lines.push("");
+}
+
+function emitToJson(name: string, lines: string[]): void {
+  lines.push(`    def to_json(self, context: SaveContext | None = None, indent: int = 2) -> str:`);
+  lines.push(`        """Convert the ${name} instance to a JSON string.`);
+  lines.push("        Args:");
+  lines.push("            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.");
+  lines.push("            indent (int): Number of spaces for indentation. Defaults to 2.");
+  lines.push("        Returns:");
+  lines.push("            str: The JSON string representation of this instance.");
+  lines.push("");
+  lines.push(`        """`);
+  lines.push("        if context is None:");
+  lines.push("            context = SaveContext()");
+  lines.push("        return context.to_json(self.save(context), indent)");
+  lines.push("");
+}
+
+// ============================================================================
+// Factory methods
+// ============================================================================
+
+function emitFactory(parentName: string, factory: FactoryDecl, visitor: ExprVisitor, fieldNames: Set<string>, lines: string[]): void {
+  const params = Object.entries(factory.params)
+    .map(([pName, pType]) => `${toSnakeCase(pName)}: ${paramType(pType)}`)
+    .join(", ");
+  const paramStr = params ? `, ${params}` : "";
+
+  // In Python, a @classmethod with the same name as a dataclass field shadows
+  // the field's default. Prefix with create_ to avoid the collision.
+  const methodName = fieldNames.has(factory.name) ? `create_${factory.name}` : factory.name;
+
+  lines.push("    @classmethod");
+  lines.push(`    def ${methodName}(cls${paramStr}) -> "${parentName}":`);
+  lines.push(`        """Create a ${parentName} with preset field values."""`);
+  lines.push(`        return ${visitor.visitExpr(factory.body)}`);
+}
diff --git a/schema/emitter/src/templates/python/context.py.njk b/schema/emitter/src/languages/python/scaffolding.ts
similarity index 59%
rename from schema/emitter/src/templates/python/context.py.njk
rename to schema/emitter/src/languages/python/scaffolding.ts
index 81a2d6df..9483254b 100644
--- a/schema/emitter/src/templates/python/context.py.njk
+++ b/schema/emitter/src/languages/python/scaffolding.ts
@@ -1,7 +1,23 @@
-{# Template for generating LoadContext and SaveContext classes #}
-{% from "macros.njk" import fileHeader %}
-{{ fileHeader(header) }}
-import json
+/**
+ * Python scaffolding emitter — static/structural files.
+ *
+ * Replaces the Nunjucks templates:
+ *   - `context.py.njk`  → emitPythonContext()
+ *   - `init.py.njk`     → emitPythonInit()
+ *
+ * These emit files whose content depends only on the type graph
+ * shape (not on the Declaration IR used for per-type files).
+ */
+
+import { TypeNode } from "../../ir/ast.js";
+
+/**
+ * Emit the _context.py file content (LoadContext + SaveContext classes).
+ * Replaces context.py.njk template.
+ */
+export function emitPythonContext(header: string): string {
+  const headerLine = header ? `# ${header}\n` : '';
+  return `${headerLine}import json
 from dataclasses import dataclass
 from typing import Any, Callable, Optional
 
@@ -125,3 +141,65 @@ class SaveContext:
             The JSON string representation.
         """
         return json.dumps(data, indent=indent)
+`;
+}
+
+/**
+ * Emit the __init__.py file content.
+ * Replaces init.py.njk template.
+ */
+export function emitPythonInit(baseTypes: TypeNode[], types: TypeNode[]): string {
+  const lines: string[] = [];
+
+  lines.push('##########################################');
+  lines.push('# WARNING: This is an auto-generated file.');
+  lines.push('# DO NOT EDIT THIS FILE DIRECTLY');
+  lines.push('# ANY EDITS WILL BE LOST');
+  lines.push('##########################################');
+  lines.push('from ._context import LoadContext, SaveContext');
+
+  for (const type of baseTypes) {
+    if (type.childTypes.length > 0) {
+      const names = [type.typeName.name, ...type.childTypes.map(c => c.typeName.name)];
+      // Also import the <Name>Helpers Protocol if this concrete type has @method stubs.
+      if (!type.isProtocol && type.methods.length > 0) {
+        names.push(`${type.typeName.name}Helpers`);
+      }
+      lines.push('');
+      lines.push(`from ._${type.typeName.name} import (`);
+      for (const name of names) {
+        lines.push(`  ${name},`);
+      }
+      lines.push(')');
+    } else {
+      const names = [type.typeName.name];
+      if (!type.isProtocol && type.methods.length > 0) {
+        names.push(`${type.typeName.name}Helpers`);
+      }
+      lines.push('');
+      if (names.length === 1) {
+        lines.push(`from ._${type.typeName.name} import ${type.typeName.name}`);
+      } else {
+        lines.push(`from ._${type.typeName.name} import (`);
+        for (const name of names) {
+          lines.push(`  ${name},`);
+        }
+        lines.push(')');
+      }
+    }
+  }
+
+  lines.push('');
+  lines.push('__all__ = [');
+  lines.push('    "LoadContext",');
+  lines.push('    "SaveContext",');
+  for (const type of types) {
+    lines.push(`    "${type.typeName.name}",`);
+    if (!type.isProtocol && type.methods.length > 0) {
+      lines.push(`    "${type.typeName.name}Helpers",`);
+    }
+  }
+  lines.push(']');
+
+  return lines.join('\n') + '\n';
+}
diff --git a/schema/emitter/src/languages/python/test-emitter.ts b/schema/emitter/src/languages/python/test-emitter.ts
new file mode 100644
index 00000000..e8b6c944
--- /dev/null
+++ b/schema/emitter/src/languages/python/test-emitter.ts
@@ -0,0 +1,402 @@
+/**
+ * Python test file emitter — BaseTestContext → pytest source code.
+ *
+ * Replaces the Nunjucks templates:
+ *   - `test.py.njk`         → emitPythonTest()
+ *   - `test_context.py.njk` → emitPythonTestContext()
+ *   - `_macros.njk`         → factoryParamTestValue(), renderValidation()
+ *
+ * The emitter produces pytest functions for:
+ *   - JSON loading (load_json per example)
+ *   - YAML loading (load_yaml per example)
+ *   - Round-trip (load → save → load per example)
+ *   - Serialization (to_json, to_yaml per example)
+ *   - Alternate representations (scalar coercions)
+ *   - Factory methods
+ */
+
+import { PropertyValidation, PythonClassContext, BaseTestContext } from "../../ir/ast.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+
+// ============================================================================
+// Macro replacements
+// ============================================================================
+
+/**
+ * Get test value for a factory parameter type.
+ * Replaces the factoryParamTestValue macro from _macros.njk.
+ */
+function factoryParamTestValue(typeStr: string): string {
+  switch (typeStr) {
+    case "string": return '"test"';
+    case "boolean": return "True";
+    case "integer":
+    case "int32":
+    case "int64": return "42";
+    case "float":
+    case "float64":
+    case "float32": return "3.14";
+    case "unknown":
+    default: return '"test"';
+  }
+}
+
+/**
+ * Render a single validation assertion line for a Python test.
+ */
+function renderValidation(v: PropertyValidation, varName: string): string {
+  if (v.value === "True") {
+    return `    assert ${varName}.${v.key}`;
+  } else if (v.value === "False") {
+    return `    assert not ${varName}.${v.key}`;
+  } else {
+    return `    assert ${varName}.${v.key} == ${v.delimiter}${v.value}${v.delimiter}`;
+  }
+}
+
+// ============================================================================
+// Test emitters
+// ============================================================================
+
+/**
+ * Emit the test_context.py file content (tests for LoadContext + SaveContext).
+ * Replaces test_context.py.njk template.
+ */
+export function emitPythonTestContext(header: string, packageName: string): string {
+  const headerLine = header ? `# ${header}\n` : '';
+  return `${headerLine}from ${packageName}._context import LoadContext, SaveContext
+
+
+class TestLoadContext:
+    """Tests for LoadContext class."""
+
+    def test_default_values(self) -> None:
+        """Test that LoadContext has correct default values."""
+        context = LoadContext()
+        assert context.pre_process is None
+        assert context.post_process is None
+
+    def test_process_input_without_callback(self) -> None:
+        """Test process_input returns original data when no callback set."""
+        context = LoadContext()
+        data = {"key": "value", "nested": {"a": 1}}
+        result = context.process_input(data)
+        assert result is data
+
+    def test_process_input_with_callback(self) -> None:
+        """Test process_input applies the pre_process callback."""
+        def add_field(data: dict) -> dict:
+            return {**data, "added": True}
+
+        context = LoadContext(pre_process=add_field)
+        data = {"key": "value"}
+        result = context.process_input(data)
+        assert result == {"key": "value", "added": True}
+        assert result is not data
+
+    def test_process_output_without_callback(self) -> None:
+        """Test process_output returns original result when no callback set."""
+        context = LoadContext()
+        result = {"some": "result"}
+        processed = context.process_output(result)
+        assert processed is result
+
+    def test_process_output_with_callback(self) -> None:
+        """Test process_output applies the post_process callback."""
+        def wrap_result(result: dict) -> dict:
+            return {"wrapped": result}
+
+        context = LoadContext(post_process=wrap_result)
+        result = {"key": "value"}
+        processed = context.process_output(result)
+        assert processed == {"wrapped": {"key": "value"}}
+
+    def test_both_callbacks(self) -> None:
+        """Test using both pre_process and post_process callbacks."""
+        def normalize_keys(data: dict) -> dict:
+            return {k.lower(): v for k, v in data.items()}
+
+        def add_metadata(result: dict) -> dict:
+            return {**result, "_processed": True}
+
+        context = LoadContext(pre_process=normalize_keys, post_process=add_metadata)
+
+        input_data = {"Key": "value", "UPPER": "case"}
+        processed_input = context.process_input(input_data)
+        assert processed_input == {"key": "value", "upper": "case"}
+
+        final_result = context.process_output(processed_input)
+        assert final_result == {"key": "value", "upper": "case", "_processed": True}
+
+    def test_pre_process_can_modify_structure(self) -> None:
+        """Test that pre_process can fundamentally transform data structure."""
+        def flatten_nested(data: dict) -> dict:
+            result = {}
+            for key, value in data.items():
+                if isinstance(value, dict):
+                    for nested_key, nested_value in value.items():
+                        result[f"{key}_{nested_key}"] = nested_value
+                else:
+                    result[key] = value
+            return result
+
+        context = LoadContext(pre_process=flatten_nested)
+        data = {"top": "level", "nested": {"a": 1, "b": 2}}
+        result = context.process_input(data)
+        assert result == {"top": "level", "nested_a": 1, "nested_b": 2}
+
+
+class TestSaveContext:
+    """Tests for SaveContext class."""
+
+    def test_default_values(self) -> None:
+        """Test that SaveContext has correct default values."""
+        context = SaveContext()
+        assert context.pre_save is None
+        assert context.post_save is None
+
+    def test_process_object_without_callback(self) -> None:
+        """Test process_object returns original object when no callback set."""
+        context = SaveContext()
+        obj = {"key": "value"}
+        result = context.process_object(obj)
+        assert result is obj
+
+    def test_process_object_with_callback(self) -> None:
+        """Test process_object applies the pre_save callback."""
+        def add_timestamp(obj: dict) -> dict:
+            return {**obj, "timestamp": "2024-01-01"}
+
+        context = SaveContext(pre_save=add_timestamp)
+        obj = {"key": "value"}
+        result = context.process_object(obj)
+        assert result == {"key": "value", "timestamp": "2024-01-01"}
+
+    def test_process_dict_without_callback(self) -> None:
+        """Test process_dict returns original dict when no callback set."""
+        context = SaveContext()
+        data = {"key": "value"}
+        result = context.process_dict(data)
+        assert result is data
+
+    def test_process_dict_with_callback(self) -> None:
+        """Test process_dict applies the post_save callback."""
+        def remove_internal_fields(data: dict) -> dict:
+            return {k: v for k, v in data.items() if not k.startswith("_")}
+
+        context = SaveContext(post_save=remove_internal_fields)
+        data = {"key": "value", "_internal": "secret"}
+        result = context.process_dict(data)
+        assert result == {"key": "value"}
+
+    def test_both_callbacks(self) -> None:
+        """Test using both pre_save and post_save callbacks."""
+        def mark_for_export(obj: dict) -> dict:
+            return {**obj, "_exporting": True}
+
+        def clean_markers(data: dict) -> dict:
+            return {k: v for k, v in data.items() if not k.startswith("_")}
+
+        context = SaveContext(pre_save=mark_for_export, post_save=clean_markers)
+
+        obj = {"name": "test", "value": 42}
+        processed_obj = context.process_object(obj)
+        assert processed_obj == {"name": "test", "value": 42, "_exporting": True}
+
+        final_dict = context.process_dict(processed_obj)
+        assert final_dict == {"name": "test", "value": 42}
+
+    def test_to_yaml(self) -> None:
+        """Test to_yaml produces valid YAML string."""
+        context = SaveContext()
+        data = {"name": "test", "items": ["a", "b"]}
+        result = context.to_yaml(data)
+        assert "name: test" in result
+        assert "items:" in result
+        assert "- a" in result
+        assert "- b" in result
+
+    def test_to_json(self) -> None:
+        """Test to_json produces valid JSON string."""
+        import json
+        context = SaveContext()
+        data = {"name": "test", "items": ["a", "b"]}
+        result = context.to_json(data)
+        parsed = json.loads(result)
+        assert parsed == data
+
+    def test_to_json_custom_indent(self) -> None:
+        """Test to_json respects custom indent."""
+        context = SaveContext()
+        data = {"name": "test"}
+        result_2 = context.to_json(data, indent=2)
+        result_4 = context.to_json(data, indent=4)
+        # 4-space indent should have more characters
+        assert len(result_4) > len(result_2)
+
+    def test_collection_format_default(self) -> None:
+        """Test that default collection_format is 'object'."""
+        context = SaveContext()
+        assert context.collection_format == "object"
+
+    def test_collection_format_array(self) -> None:
+        """Test collection_format can be set to 'array'."""
+        context = SaveContext(collection_format="array")
+        assert context.collection_format == "array"
+
+    def test_use_shorthand_default(self) -> None:
+        """Test that default use_shorthand is True."""
+        context = SaveContext()
+        assert context.use_shorthand is True
+
+    def test_use_shorthand_disabled(self) -> None:
+        """Test use_shorthand can be disabled."""
+        context = SaveContext(use_shorthand=False)
+        assert context.use_shorthand is False
+`;
+}
+
+/**
+ * Emit a pytest test file for a type.
+ * Replaces test.py.njk template.
+ */
+export function emitPythonTest(ctx: BaseTestContext & { classCtx: PythonClassContext }): string {
+  const { node, examples, coercions, factories, classCtx } = ctx;
+  const packageName = ctx.package || '';
+  const typeName = node.typeName.name;
+  const typeNameLower = typeName.toLowerCase();
+  const lines: string[] = [];
+
+  // Imports
+  if (examples.length > 0) {
+    lines.push('import json');
+    lines.push('import yaml');
+    lines.push('');
+  }
+  lines.push(`from ${packageName} import ${typeName}`);
+  lines.push('');
+
+  // Example tests: load_json, load_yaml, roundtrip_json, to_json, to_yaml
+  for (let i = 0; i < examples.length; i++) {
+    const sample = examples[i];
+    const suffix = i === 0 ? '' : `_${i}`;
+    const jsonBlock = sample.json.map(line => `    ${line}`).join('\n');
+    const yamlBlock = sample.yaml.map(line => `    ${line}`).join('\n');
+
+    // test_load_json
+    lines.push(`def test_load_json_${typeNameLower}${suffix}():`);
+    lines.push(`    json_data = r'''`);
+    lines.push(jsonBlock);
+    lines.push(`    '''`);
+    lines.push(`    data = json.loads(json_data, strict=False)`);
+    lines.push(`    instance = ${typeName}.load(data)`);
+    lines.push(`    assert instance is not None`);
+    for (const v of sample.validations) {
+      lines.push(renderValidation(v, 'instance'));
+    }
+    lines.push('');
+
+    // test_load_yaml
+    lines.push(`def test_load_yaml_${typeNameLower}${suffix}():`);
+    lines.push(`    yaml_data = r'''`);
+    lines.push(yamlBlock);
+    lines.push(`    '''`);
+    lines.push(`    data = yaml.load(yaml_data, Loader=yaml.FullLoader)`);
+    lines.push(`    instance = ${typeName}.load(data)`);
+    lines.push(`    assert instance is not None`);
+    for (const v of sample.validations) {
+      lines.push(renderValidation(v, 'instance'));
+    }
+    lines.push('');
+
+    // test_roundtrip_json
+    lines.push(`def test_roundtrip_json_${typeNameLower}${suffix}():`);
+    lines.push(`    """Test that load -> save -> load produces equivalent data."""`);
+    lines.push(`    json_data = r'''`);
+    lines.push(jsonBlock);
+    lines.push(`    '''`);
+    lines.push(`    original_data = json.loads(json_data, strict=False)`);
+    lines.push(`    instance = ${typeName}.load(original_data)`);
+    lines.push(`    saved_data = instance.save()`);
+    lines.push(`    reloaded = ${typeName}.load(saved_data)`);
+    lines.push(`    assert reloaded is not None`);
+    for (const v of sample.validations) {
+      lines.push(renderValidation(v, 'reloaded'));
+    }
+    lines.push('');
+
+    // test_to_json
+    lines.push(`def test_to_json_${typeNameLower}${suffix}():`);
+    lines.push(`    """Test that to_json produces valid JSON."""`);
+    lines.push(`    json_data = r'''`);
+    lines.push(jsonBlock);
+    lines.push(`    '''`);
+    lines.push(`    data = json.loads(json_data, strict=False)`);
+    lines.push(`    instance = ${typeName}.load(data)`);
+    lines.push(`    json_output = instance.to_json()`);
+    lines.push(`    assert json_output is not None`);
+    lines.push(`    parsed = json.loads(json_output)`);
+    lines.push(`    assert isinstance(parsed, dict)`);
+    lines.push('');
+
+    // test_to_yaml
+    lines.push(`def test_to_yaml_${typeNameLower}${suffix}():`);
+    lines.push(`    """Test that to_yaml produces valid YAML."""`);
+    lines.push(`    json_data = r'''`);
+    lines.push(jsonBlock);
+    lines.push(`    '''`);
+    lines.push(`    data = json.loads(json_data, strict=False)`);
+    lines.push(`    instance = ${typeName}.load(data)`);
+    lines.push(`    yaml_output = instance.to_yaml()`);
+    lines.push(`    assert yaml_output is not None`);
+    lines.push(`    parsed = yaml.safe_load(yaml_output)`);
+    lines.push(`    assert isinstance(parsed, dict)`);
+    lines.push('');
+  }
+
+  // Coercion tests
+  if (coercions.length > 0) {
+    for (const alt of coercions) {
+      lines.push(`def test_load_${typeNameLower}_from_${alt.scalarType}():`);
+      lines.push(`    instance = ${typeName}.load(${alt.value})`);
+      lines.push(`    assert instance is not None`);
+      for (const v of alt.validations) {
+        lines.push(renderValidation(v, 'instance'));
+      }
+      lines.push('');
+    }
+  }
+
+  // Factory tests
+  if (factories.length > 0) {
+    for (const factory of factories) {
+      const safeName = classCtx.factoryNameMap[factory.name];
+      const factorySnake = toSnakeCase(factory.name);
+      const params = Object.entries(factory.params)
+        .map(([_, pType]) => factoryParamTestValue(pType))
+        .join(', ');
+
+      lines.push(`def test_factory_${factorySnake}_${typeNameLower}():`);
+      lines.push(`    """Test that ${factory.name}() factory creates a valid instance."""`);
+      lines.push(`    instance = ${typeName}.${safeName}(${params})`);
+      lines.push(`    assert instance is not None`);
+      lines.push(`    assert isinstance(instance, ${typeName})`);
+
+      for (const [propName, value] of Object.entries(factory.sets)) {
+        const snakeProp = toSnakeCase(propName);
+        if (value === true) {
+          lines.push(`    assert instance.${snakeProp}`);
+        } else if (value === false) {
+          lines.push(`    assert not instance.${snakeProp}`);
+        } else if (typeof value === 'number') {
+          lines.push(`    assert instance.${snakeProp} == ${value}`);
+        } else if (typeof value === 'string') {
+          lines.push(`    assert instance.${snakeProp} == "${value}"`);
+        }
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n') + '\n';
+}
diff --git a/schema/emitter/src/languages/python/visitor.ts b/schema/emitter/src/languages/python/visitor.ts
new file mode 100644
index 00000000..d8092a99
--- /dev/null
+++ b/schema/emitter/src/languages/python/visitor.ts
@@ -0,0 +1,77 @@
+/**
+ * Python expression visitor — Expr IR → Python source fragments.
+ */
+
+import { Expr, Construct, VariantConstruct, ArrayLiteral, TypeRegistry } from "../../ir/expansion.js";
+import { ExprVisitor, assertNever } from "../../ir/visitor.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+
+export class PythonExprVisitor implements ExprVisitor {
+  registry?: TypeRegistry;
+
+  constructor(registry?: TypeRegistry) {
+    this.registry = registry;
+  }
+
+  visitExpr(expr: Expr): string {
+    switch (expr.kind) {
+      case "string":
+        return `"${this.escapeString(expr.value)}"`;
+      case "number":
+        return String(expr.value);
+      case "boolean":
+        return expr.value ? "True" : "False";
+      case "null":
+        return "None";
+      case "param":
+        return toSnakeCase(expr.name);
+      case "construct":
+        return this.visitConstruct(expr);
+      case "variant":
+        return this.visitVariant(expr);
+      case "array":
+        return this.visitArray(expr);
+      case "dict":
+        return `{${expr.entries.map(e => `"${e.key}": ${this.visitExpr(e.value)}`).join(", ")}}`;
+      case "field_read":
+        return `${toSnakeCase(expr.objectName)}.${toSnakeCase(expr.fieldName)}`;
+      default:
+        return assertNever(expr);
+    }
+  }
+
+  private visitConstruct(expr: Construct): string {
+    const typeName = expr.typeName.name;
+    if (expr.fields.length === 0) {
+      return `${typeName}()`;
+    }
+    const fields = expr.fields.map(f =>
+      `${toSnakeCase(f.propertyName)}=${this.visitExpr(f.value)}`
+    ).join(", ");
+    return `${typeName}(${fields})`;
+  }
+
+  private visitVariant(expr: VariantConstruct): string {
+    // In Python, polymorphic children are full classes
+    const variantName = expr.variantTypeName.name;
+    if (expr.fields.length === 0) {
+      return `${variantName}()`;
+    }
+    const fields = expr.fields.map(f =>
+      `${toSnakeCase(f.propertyName)}=${this.visitExpr(f.value)}`
+    ).join(", ");
+    return `${variantName}(${fields})`;
+  }
+
+  private visitArray(expr: ArrayLiteral): string {
+    if (expr.items.length === 0) {
+      return "[]";
+    }
+    const items = expr.items.map(i => this.visitExpr(i)).join(", ");
+    return `[${items}]`;
+  }
+
+  private escapeString(s: string): string {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+}
diff --git a/schema/emitter/src/languages/rust/driver.ts b/schema/emitter/src/languages/rust/driver.ts
new file mode 100644
index 00000000..d715c610
--- /dev/null
+++ b/schema/emitter/src/languages/rust/driver.ts
@@ -0,0 +1,547 @@
+import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { EmitTarget, PromptyEmitterOptions } from "../../lib.js";
+import {
+  BaseTestContext,
+  enumerateTypes,
+  TypeNode,
+} from "../../ir/ast.js";
+import { GeneratorOptions, filterNodes } from "../../emitter.js";
+import { TypeRegistry } from "../../ir/expansion.js";
+import { RustExprVisitor } from "./visitor.js";
+import { buildBaseTestContext, rustTestOptions } from "../../testing/test-context.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+import { lowerFile, collectPolymorphicTypeNames } from "../../ir/lower.js";
+import { emitRustFile as emitRustFileDecl } from "./emitter.js";
+
+/**
+ * Type mapping from TypeSpec scalar types to Rust types.
+ * Retained for use by the test template context.
+ */
+export const rustTypeMapper: Record<string, string> = {
+  "string": "String",
+  "number": "f64",
+  "array": "Vec<serde_json::Value>",
+  "object": "serde_json::Value",
+  "boolean": "bool",
+  "int64": "i64",
+  "int32": "i32",
+  "float64": "f64",
+  "float32": "f32",
+  "integer": "i64",
+  "float": "f64",
+  "numeric": "f64",
+  "any": "serde_json::Value",
+  "dictionary": "serde_json::Value",
+};
+
+interface RustLibContext {
+  modules: string[];
+}
+
+/**
+ * Main entry point for Rust code generation.
+ */
+export const generateRust = async (
+  context: EmitContext<PromptyEmitterOptions>,
+  node: TypeNode,
+  emitTarget: EmitTarget,
+  options?: GeneratorOptions
+): Promise<void> => {
+  const allTypes = Array.from(enumerateTypes(node));
+  const nodes = filterNodes(allTypes, options);
+
+  // Build the expression IR infrastructure for this compilation
+  const registry = TypeRegistry.fromTypeGraph(allTypes);
+  const visitor = new RustExprVisitor(registry);
+
+  // Collect all polymorphic type names across all nodes
+  const polymorphicTypeNames = new Set<string>();
+  for (const n of nodes) {
+    for (const name of collectPolymorphicTypeNames(n, registry)) {
+      polymorphicTypeNames.add(name);
+    }
+  }
+  // Build a map from polymorphic child type names to their parent type names.
+  // In Rust, child types become enum variants, not standalone structs.
+  // When importing a child type, we need to import ParentKind instead.
+  const childToParent = new Map<string, string>();
+  for (const n of nodes) {
+    if (n.discriminator && n.childTypes.length > 0) {
+      for (const child of n.childTypes) {
+        childToParent.set(child.typeName.name, n.typeName.name);
+      }
+    }
+  }
+
+  // Render context.rs
+  const contextContent = emitRustContext("Prompty Context");
+  await emitRustFile(context, 'context.rs', contextContent, emitTarget["output-dir"]);
+
+  // Render each base type and its children as a single file
+  const moduleNames: string[] = ['context'];
+  const testModuleNames: string[] = [];
+  for (const n of nodes) {
+    if (!n.base) {
+      const fileDecl = lowerFile(n, registry, polymorphicTypeNames);
+      const fileContent = emitRustFileDecl(fileDecl, visitor, polymorphicTypeNames, childToParent);
+      const fileName = toSnakeCase(n.typeName.name) + '.rs';
+      await emitRustFile(context, fileName, fileContent, emitTarget["output-dir"]);
+      moduleNames.push(toSnakeCase(n.typeName.name));
+    }
+
+    // Render test file — skip children of polymorphic hierarchies (they're enum variants now) and protocols
+    if (emitTarget["test-dir"] && !childToParent.has(n.typeName.name) && !n.isProtocol) {
+      const importPath = emitTarget["import-path"] || "crate";
+      const testContext = buildTestContext(n);
+      const isPolymorphicBase = !!(n.discriminator && n.childTypes.length > 0);
+      const testContent = emitRustTest({
+        ...testContext,
+        importPath,
+        isPolymorphicBase,
+      });
+      const testFileName = toSnakeCase(n.typeName.name) + '_test.rs';
+      await emitRustFile(context, testFileName, testContent, emitTarget["test-dir"]);
+      testModuleNames.push(toSnakeCase(n.typeName.name) + '_test');
+    }
+  }
+
+  // Render test main.rs (module declarations for the test harness)
+  if (emitTarget["test-dir"]) {
+    const mainContent = '// Code generated by AgentSchema emitter; DO NOT EDIT.\n\n'
+      + testModuleNames.map(m => `mod ${m};`).join('\n') + '\n';
+    await emitRustFile(context, 'main.rs', mainContent, emitTarget["test-dir"]);
+  }
+
+  // Render mod.rs (module declarations for embedding as a submodule)
+  const libContext: RustLibContext = { modules: moduleNames };
+  const libContent = emitRustLib(libContext.modules);
+  await emitRustFile(context, 'mod.rs', libContent, emitTarget["output-dir"]);
+
+  // Format emitted files
+  if (emitTarget.format !== false) {
+    const outputDir = emitTarget["output-dir"]
+      ? resolve(process.cwd(), emitTarget["output-dir"])
+      : context.emitterOutputDir;
+    formatRustFiles(outputDir);
+  }
+};
+
+/**
+ * Format Rust files using cargo fmt.
+ */
+function formatRustFiles(outputDir: string): void {
+  // Run cargo fmt if Cargo.toml exists in parent
+  const cargoToml = resolve(outputDir, '../Cargo.toml');
+  if (existsSync(cargoToml)) {
+    try {
+      execFileSync("cargo", ["fmt", "--manifest-path", cargoToml], {
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      });
+    } catch (error) {
+      console.warn(`Warning: cargo fmt failed. You may need to install Rust.`);
+    }
+  }
+}
+
+/**
+ * Build context for rendering a test file.
+ */
+function buildTestContext(node: TypeNode): BaseTestContext {
+  return buildBaseTestContext(node, undefined, rustTestOptions);
+}
+
+/**
+ * Write generated Rust content to file.
+ */
+async function emitRustFile(
+  context: EmitContext<PromptyEmitterOptions>,
+  filename: string,
+  content: string,
+  outputDir?: string
+): Promise<void> {
+  outputDir = outputDir || `${context.emitterOutputDir}/rust`;
+  const filePath = resolvePath(outputDir, filename);
+  await emitFile(context.program, {
+    path: filePath,
+    content,
+  });
+}
+
+/**
+ * Emit the context.rs file content (LoadContext/SaveContext structs).
+ */
+function emitRustContext(header: string): string {
+  return `// Code generated by AgentSchema emitter; DO NOT EDIT.
+// ${header}
+
+/// Callback type for pre-processing input data before parsing.
+pub type PreProcessFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
+
+/// Callback type for post-processing the result after instantiation.
+pub type PostProcessFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
+
+/// Callback type for pre-processing an object before serialization.
+pub type PreSaveFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
+
+/// Callback type for post-processing a dictionary after serialization.
+pub type PostSaveFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
+
+/// Context for customizing the loading process of agent definitions.
+///
+/// Provides hooks for pre-processing input data before parsing and
+/// post-processing output data after instantiation.
+pub struct LoadContext {
+    /// Optional callback to transform input data before parsing.
+    pub pre_process: Option<PreProcessFn>,
+    /// Optional callback to transform the result after instantiation.
+    pub post_process: Option<PostProcessFn>,
+}
+
+impl std::fmt::Debug for LoadContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("LoadContext")
+            .field("pre_process", &self.pre_process.as_ref().map(|_| "..."))
+            .field("post_process", &self.post_process.as_ref().map(|_| "..."))
+            .finish()
+    }
+}
+
+impl Default for LoadContext {
+    fn default() -> Self {
+        Self {
+            pre_process: None,
+            post_process: None,
+        }
+    }
+}
+
+impl LoadContext {
+    /// Create a new empty LoadContext.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Apply pre-processing to input data if a pre_process callback is set.
+    ///
+    /// # Arguments
+    /// * \`data\` - The raw input value to process.
+    ///
+    /// # Returns
+    /// The processed value, or the original if no callback is set.
+    pub fn process_input(&self, data: serde_json::Value) -> serde_json::Value {
+        if let Some(ref f) = self.pre_process {
+            f(data)
+        } else {
+            data
+        }
+    }
+
+    /// Apply post-processing to the result if a post_process callback is set.
+    ///
+    /// # Arguments
+    /// * \`result\` - The instantiated value to process.
+    ///
+    /// # Returns
+    /// The processed result, or the original if no callback is set.
+    pub fn process_output(&self, result: serde_json::Value) -> serde_json::Value {
+        if let Some(ref f) = self.post_process {
+            f(result)
+        } else {
+            result
+        }
+    }
+}
+
+/// Context for customizing the serialization process of agent definitions.
+///
+/// Provides hooks for pre-processing the object before serialization and
+/// post-processing the dictionary after serialization.
+pub struct SaveContext {
+    /// Optional callback to transform the object before serialization.
+    pub pre_save: Option<PreSaveFn>,
+    /// Optional callback to transform the dictionary after serialization.
+    pub post_save: Option<PostSaveFn>,
+    /// Output format for collections: "object" (name as key) or "array" (list of dicts).
+    /// Defaults to "object".
+    pub collection_format: String,
+    /// Use shorthand scalar representation when possible.
+    /// Defaults to true.
+    pub use_shorthand: bool,
+}
+
+impl std::fmt::Debug for SaveContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SaveContext")
+            .field("pre_save", &self.pre_save.as_ref().map(|_| "..."))
+            .field("post_save", &self.post_save.as_ref().map(|_| "..."))
+            .field("collection_format", &self.collection_format)
+            .field("use_shorthand", &self.use_shorthand)
+            .finish()
+    }
+}
+
+impl Default for SaveContext {
+    fn default() -> Self {
+        Self {
+            pre_save: None,
+            post_save: None,
+            collection_format: "object".to_string(),
+            use_shorthand: true,
+        }
+    }
+}
+
+impl SaveContext {
+    /// Create a new SaveContext with defaults.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Apply pre-processing to the object if a pre_save callback is set.
+    ///
+    /// # Arguments
+    /// * \`obj\` - The value to process before serialization.
+    ///
+    /// # Returns
+    /// The processed value, or the original if no callback is set.
+    pub fn process_object(&self, obj: serde_json::Value) -> serde_json::Value {
+        if let Some(ref f) = self.pre_save {
+            f(obj)
+        } else {
+            obj
+        }
+    }
+
+    /// Apply post-processing to the dictionary if a post_save callback is set.
+    ///
+    /// # Arguments
+    /// * \`data\` - The serialized value to process.
+    ///
+    /// # Returns
+    /// The processed value, or the original if no callback is set.
+    pub fn process_dict(&self, data: serde_json::Value) -> serde_json::Value {
+        if let Some(ref f) = self.post_save {
+            f(data)
+        } else {
+            data
+        }
+    }
+
+    /// Convert a value to a YAML string.
+    pub fn to_yaml(&self, data: &serde_json::Value) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(data)
+    }
+
+    /// Convert a value to a JSON string.
+    pub fn to_json(&self, data: &serde_json::Value, indent: bool) -> Result<String, serde_json::Error> {
+        if indent {
+            serde_json::to_string_pretty(data)
+        } else {
+            serde_json::to_string(data)
+        }
+    }
+}
+`;
+}
+
+/**
+ * Emit the mod.rs file content (module declarations).
+ */
+function emitRustLib(modules: string[]): string {
+  let out = '// Code generated by AgentSchema emitter; DO NOT EDIT.\n';
+  for (const module of modules) {
+    out += `\npub mod ${module};\npub use ${module}::*;\n`;
+  }
+  return out;
+}
+
+/**
+ * Map a factory parameter type string to a Rust test value literal.
+ */
+function factoryParamTestValue(typeStr: string): string {
+  switch (typeStr) {
+    case "string": return '"test".to_string()';
+    case "boolean": return "true";
+    case "integer":
+    case "int32": return "42";
+    case "int64": return "42i64";
+    case "float":
+    case "float64": return "3.14";
+    case "unknown": return 'serde_json::json!("test")';
+    default: return 'serde_json::json!("test")';
+  }
+}
+
+interface RustTestContext extends BaseTestContext {
+  importPath: string;
+  isPolymorphicBase: boolean;
+}
+
+/**
+ * Emit an integration test file for a TypeSpec model type.
+ */
+function emitRustTest(ctx: RustTestContext): string {
+  const { node, isAbstract, examples, coercions, factories, importPath, isPolymorphicBase } = ctx;
+  const typeName = node.typeName.name;
+  const snakeName = toSnakeCase(typeName);
+  let out = '';
+
+  out += '// Code generated by AgentSchema emitter; DO NOT EDIT.\n';
+  out += '\n';
+  out += `use ${importPath}::${typeName};\n`;
+  out += `use ${importPath}::context::{LoadContext, SaveContext};\n`;
+  out += '\n';
+
+  // Example tests (load JSON, load YAML, roundtrip)
+  for (let i = 0; i < examples.length; i++) {
+    const sample = examples[i];
+    const suffix = i === 0 ? '' : `_${i}`;
+
+    // JSON load test
+    out += '#[test]\n';
+    out += `fn test_${snakeName}_load_json${suffix}() {\n`;
+    out += '    let json = r####"\n';
+    for (const line of sample.json) {
+      out += `${line}\n`;
+    }
+    out += '"####;\n';
+    out += '    let ctx = LoadContext::default();\n';
+    out += `    let result = ${typeName}::from_json(json, &ctx);\n`;
+    out += '    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());\n';
+    if (!isAbstract) {
+      out += '    let instance = result.unwrap();\n';
+      if (sample.validations.length > 0) {
+        for (const v of sample.validations) {
+          if (v.isOptional) {
+            out += `    assert!(instance.${v.key}.is_some(), "Expected ${v.key} to be Some");\n`;
+            out += `    assert_eq!(instance.${v.key}.as_ref().unwrap(), &${v.delimiter}${v.value}${v.delimiter});\n`;
+          } else if (isPolymorphicBase && v.key === "kind") {
+            out += `    assert_eq!(instance.kind_str(), ${v.delimiter}${v.value}${v.delimiter});\n`;
+          } else {
+            out += `    assert_eq!(instance.${v.key}, ${v.delimiter}${v.value}${v.delimiter});\n`;
+          }
+        }
+      } else {
+        out += '    let _ = instance; // load succeeded, no scalar properties to validate\n';
+      }
+    }
+    out += '}\n';
+    out += '\n';
+
+    // YAML load test
+    out += '#[test]\n';
+    out += `fn test_${snakeName}_load_yaml${suffix}() {\n`;
+    out += '    let yaml = r####"\n';
+    for (const line of sample.yaml) {
+      out += `${line}\n`;
+    }
+    out += '"####;\n';
+    out += '    let ctx = LoadContext::default();\n';
+    out += `    let result = ${typeName}::from_yaml(yaml, &ctx);\n`;
+    out += '    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());\n';
+    if (!isAbstract) {
+      out += '    let instance = result.unwrap();\n';
+      if (sample.validations.length > 0) {
+        for (const v of sample.validations) {
+          if (v.isOptional) {
+            out += `    assert!(instance.${v.key}.is_some(), "Expected ${v.key} to be Some");\n`;
+          } else if (isPolymorphicBase && v.key === "kind") {
+            out += `    assert_eq!(instance.kind_str(), ${v.delimiter}${v.value}${v.delimiter});\n`;
+          } else {
+            out += `    assert_eq!(instance.${v.key}, ${v.delimiter}${v.value}${v.delimiter});\n`;
+          }
+        }
+      } else {
+        out += '    let _ = instance; // load succeeded, no scalar properties to validate\n';
+      }
+    }
+    out += '}\n';
+    out += '\n';
+
+    // Roundtrip test
+    out += '#[test]\n';
+    out += `fn test_${snakeName}_roundtrip${suffix}() {\n`;
+    out += '    let json = r####"\n';
+    for (const line of sample.json) {
+      out += `${line}\n`;
+    }
+    out += '"####;\n';
+    out += '    let load_ctx = LoadContext::default();\n';
+    out += `    let result = ${typeName}::from_json(json, &load_ctx);\n`;
+    out += '    assert!(result.is_ok(), "Failed to load: {:?}", result.err());\n';
+    if (!isAbstract) {
+      out += '    let instance = result.unwrap();\n';
+      out += '    let save_ctx = SaveContext::default();\n';
+      out += '    let json_output = instance.to_json(&save_ctx);\n';
+      out += '    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());\n';
+    }
+    out += '}\n';
+    out += '\n';
+  }
+
+  // Coercion tests
+  for (let i = 0; i < coercions.length; i++) {
+    const alt = coercions[i];
+    const suffix = i === 0 ? '' : `_${i + 1}`;
+
+    out += '#[test]\n';
+    out += `fn test_${snakeName}_from_${alt.title.toLowerCase()}${suffix}() {\n`;
+    out += `    let value = serde_json::json!(${alt.value});\n`;
+    out += '    let ctx = LoadContext::default();\n';
+    out += `    let instance = ${typeName}::load_from_value(&value, &ctx);\n`;
+    if (!isAbstract) {
+      if (alt.validations.length > 0) {
+        for (const item of alt.validations) {
+          if (item.isOptional) {
+            out += `    assert!(instance.${item.key}.is_some());\n`;
+          } else if (isPolymorphicBase && item.key === "kind") {
+            out += `    assert_eq!(instance.kind_str(), ${item.delimiter}${item.value}${item.delimiter});\n`;
+          } else {
+            out += `    assert_eq!(instance.${item.key}, ${item.delimiter}${item.value}${item.delimiter});\n`;
+          }
+        }
+      } else {
+        out += '    let _ = instance; // load succeeded, no scalar properties to validate\n';
+      }
+    } else {
+      out += '    let _ = instance; // abstract type, load succeeded\n';
+    }
+    out += '}\n';
+    out += '\n';
+  }
+
+  // Factory tests
+  for (const factory of factories) {
+    const factorySnake = toSnakeCase(factory.name);
+    const paramEntries = Object.entries(factory.params);
+    const paramValues = paramEntries.map(([, pType]) => factoryParamTestValue(pType)).join(', ');
+
+    out += '#[test]\n';
+    out += `fn test_${snakeName}_factory_${factorySnake}() {\n`;
+    out += `    let instance = ${typeName}::${factorySnake}(${paramValues});\n`;
+
+    for (const [propName, value] of Object.entries(factory.sets)) {
+      if (value === true) {
+        out += `    assert!(instance.${toSnakeCase(propName)});\n`;
+      } else if (value === false) {
+        out += `    assert!(!instance.${toSnakeCase(propName)});\n`;
+      }
+    }
+
+    for (const [pName] of paramEntries) {
+      const prop = node.properties.find(p => p.name === pName);
+      if (prop && prop.isOptional) {
+        out += `    assert!(instance.${toSnakeCase(pName)}.is_some());\n`;
+      }
+    }
+
+    out += '}\n';
+    out += '\n';
+  }
+
+  return out;
+}
diff --git a/schema/emitter/src/languages/rust/emitter.ts b/schema/emitter/src/languages/rust/emitter.ts
new file mode 100644
index 00000000..9905819f
--- /dev/null
+++ b/schema/emitter/src/languages/rust/emitter.ts
@@ -0,0 +1,1641 @@
+/**
+ * Rust code emitter — Declaration IR → Rust source code.
+ *
+ * Replaces `file.rs.njk` + `_macros.njk` (~1,072 lines of Nunjucks templates)
+ * with a typed TypeScript function that walks the FileDecl tree.
+ *
+ * The emitter produces Rust code using the struct + enum pattern for
+ * polymorphic types. Output is post-processed by `cargo fmt`.
+ *
+ * Key Rust-specific patterns:
+ *   - Polymorphic types use struct + XxxKind enum (not inheritance)
+ *   - Variant-specific fields live on enum variants, not child classes
+ *   - Polymorphic single-ref fields → serde_json::Value
+ *   - Ownership: String, Option<T>, Vec<T>
+ *   - Pattern matching for load/save of variant fields
+ *
+ * Structural blocks emitted (in order):
+ *   1. Header comment (auto-generated warning)
+ *   2. Imports (context, referenced types)
+ *   3. For each polymorphic type:
+ *      a. XxxKind enum with inline struct variants
+ *      b. impl Default for XxxKind
+ *   4. For each type:
+ *      a. Struct definition with #[derive(Debug, Clone, Default)]
+ *      b. impl block:
+ *         - new(), from_json(), from_yaml()
+ *         - load_from_value()
+ *         - kind_str() (polymorphic only)
+ *         - to_value(), to_json(), to_yaml()
+ *         - to_wire() (when wire mappings exist)
+ *         - Collection helpers
+ *         - Factory methods
+ *         - Method stubs (as trait)
+ */
+
+import {
+  FileDecl,
+  TypeDecl,
+  FieldDecl,
+  LoadAssignment,
+  SaveAssignment,
+  CollectionHelperDecl,
+  PolymorphicDispatchDecl,
+  PolymorphicVariant,
+  FactoryDecl,
+  CoercionDecl,
+  PropertyCategory,
+  MethodStubDecl,
+  WireDecl,
+} from "../../ir/declarations.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+
+/**
+ * Emit a description as a single-line `///` doc comment.
+ * Multi-line descriptions are collapsed to a single line.
+ */
+function emitDocComment(description: string, indent: string, lines: string[]): void {
+  // Collapse multi-line descriptions to a single line
+  const oneLine = description.replace(/\r?\n/g, " ").replace(/\s+/g, " ").trim();
+  lines.push(`${indent}/// ${oneLine}`);
+}
+
+/**
+ * Type mapping from TypeSpec scalar types to Rust types.
+ */
+const RUST_TYPE_MAP: Record<string, string> = {
+  string: "String",
+  boolean: "bool",
+  int32: "i32",
+  int64: "i64",
+  float32: "f32",
+  float64: "f64",
+  integer: "i64",
+  float: "f64",
+  numeric: "f64",
+  number: "f64",
+  any: "serde_json::Value",
+  unknown: "serde_json::Value",
+  object: "serde_json::Value",
+  dictionary: "serde_json::Value",
+  array: "Vec<serde_json::Value>",
+};
+
+/**
+ * Emit a complete Rust source file from a FileDecl.
+ */
+export function emitRustFile(
+  file: FileDecl,
+  visitor: ExprVisitor,
+  polymorphicTypeNames: Set<string>,
+  childToParent: Map<string, string> = new Map(),
+): string {
+  const lines: string[] = [];
+  const hasNonProtocol = file.types.some(t => !t.isProtocol);
+
+  // Header
+  lines.push("");
+  lines.push("");
+  lines.push("// Code generated by AgentSchema emitter; DO NOT EDIT.");
+  lines.push("");
+  lines.push("#![allow(unused_imports, dead_code)]");
+  lines.push("");
+  if (hasNonProtocol) {
+    lines.push("use super::context::{LoadContext, SaveContext};");
+  }
+
+  // Imports — post-process for Rust specifics
+  // In Rust, polymorphic child types are enum variants (not standalone structs),
+  // so we import ParentKind instead.
+  for (const imp of file.imports) {
+    const processedNames: string[] = [];
+
+    for (const name of imp.names) {
+      // Check if this name is a polymorphic child → import ParentKind
+      const parentName = childToParent.get(name);
+      if (parentName) {
+        const kindName = parentName + "Kind";
+        if (!processedNames.includes(kindName)) {
+          processedNames.push(kindName);
+        }
+        continue;
+      }
+      processedNames.push(name);
+    }
+    if (processedNames.length === 0) continue;
+    lines.push("");
+    const names = processedNames.sort().join(", ");
+    if (processedNames.length === 1) {
+      lines.push(`use super::${toSnakeCase(imp.module)}::${names};`);
+    } else {
+      lines.push(`use super::${toSnakeCase(imp.module)}::{${names}};`);
+    }
+  }
+
+  lines.push("");
+
+  // Find the base type (the one that owns the polymorphic dispatch)
+  const baseType = file.types.find(t => t.polymorphicDispatch) || file.types[0];
+  const childTypes = file.types.filter(t => t !== baseType);
+
+  // Protocol types → emit as trait (no struct, no impl)
+  if (baseType.isProtocol) {
+    emitProtocolTrait(baseType, lines);
+    lines.push("");
+    return lines.join("\n");
+  }
+
+  // Collect base field names for variant field extraction
+  const baseFieldNames = new Set(baseType.fields.map(f => f.name));
+
+  // Emit enum for polymorphic types
+  if (baseType.polymorphicDispatch) {
+    emitKindEnum(baseType, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+  }
+
+  // Emit struct + impl for the base type (only one struct per file in Rust)
+  emitStruct(baseType, polymorphicTypeNames, lines);
+  emitImpl(baseType, childTypes, baseFieldNames, visitor, polymorphicTypeNames, lines);
+
+  // Method stubs as trait
+  if (baseType.methods.length > 0) {
+    emitMethodTrait(baseType, lines);
+  }
+
+  // Trailing newlines for child types that were folded into the enum
+  for (const _ of childTypes) {
+    lines.push("");
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}
+
+// ============================================================================
+// Kind Enum
+// ============================================================================
+
+function emitKindEnum(
+  baseType: TypeDecl,
+  childTypes: TypeDecl[],
+  baseFieldNames: Set<string>,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const dispatch = baseType.polymorphicDispatch!;
+  const enumName = baseType.typeName.name + "Kind";
+
+  lines.push("");
+  lines.push(`/// Variant-specific data for [\`${baseType.typeName.name}\`], discriminated by \`${dispatch.discriminatorField}\`.`);
+  lines.push("#[derive(Debug, Clone)]");
+  lines.push(`pub enum ${enumName} {`);
+
+  // Named variants
+  for (const variant of dispatch.variants) {
+    const childType = childTypes.find(ct => ct.typeName.name === variant.typeName.name);
+    const variantName = variant.typeName.name.replace(baseType.typeName.name, "") || variant.typeName.name;
+    const variantFields = childType
+      ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+      : [];
+
+    lines.push(`    /// \`${dispatch.discriminatorField}\` = \`"${variant.value}"\``);
+    if (variantFields.length === 0) {
+      lines.push(`    ${variantName},`);
+    } else {
+      lines.push(`    ${variantName} {`);
+      for (const field of variantFields) {
+        if (field.description) {
+          emitDocComment(field.description, "        ", lines);
+        }
+        lines.push(`        ${toSnakeCase(field.name)}: ${fieldType(field, polymorphicTypeNames)},`);
+      }
+      lines.push(`    },`);
+    }
+  }
+
+  // Wildcard/default variant
+  if (dispatch.defaultVariant) {
+    const defaultType = childTypes.find(ct => ct.typeName.name === dispatch.defaultVariant!.typeName.name);
+    const isSelfRef = dispatch.defaultVariant.isSelfReference;
+    const variantName = isSelfRef
+      ? "Custom"
+      : (dispatch.defaultVariant.typeName.name.replace(baseType.typeName.name, "") || "Custom");
+
+    const variantFields = isSelfRef
+      ? []
+      : (defaultType
+          ? defaultType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+          : []);
+
+    lines.push(`    /// Wildcard / catch-all variant for unrecognized \`${dispatch.discriminatorField}\` values.`);
+    // Wildcard always has kind_name field
+    if (variantFields.length === 0) {
+      lines.push(`    ${variantName} {`);
+      lines.push(`        /// The raw \`${dispatch.discriminatorField}\` string for this unknown variant.`);
+      lines.push(`        ${toSnakeCase(dispatch.discriminatorField)}_name: String,`);
+      lines.push(`    },`);
+    } else {
+      lines.push(`    ${variantName} {`);
+      for (const field of variantFields) {
+        if (field.description) {
+          emitDocComment(field.description, "        ", lines);
+        }
+        lines.push(`        ${toSnakeCase(field.name)}: ${fieldType(field, polymorphicTypeNames)},`);
+      }
+      lines.push(`        /// The raw \`${dispatch.discriminatorField}\` string for this unknown variant.`);
+      lines.push(`        ${toSnakeCase(dispatch.discriminatorField)}_name: String,`);
+      lines.push(`    },`);
+    }
+  }
+
+  lines.push("}");
+  lines.push("");
+
+  // impl Default for the enum
+  emitEnumDefault(baseType, childTypes, baseFieldNames, dispatch, polymorphicTypeNames, lines);
+}
+
+function emitEnumDefault(
+  baseType: TypeDecl,
+  childTypes: TypeDecl[],
+  baseFieldNames: Set<string>,
+  dispatch: PolymorphicDispatchDecl,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const enumName = baseType.typeName.name + "Kind";
+
+  lines.push(`impl Default for ${enumName} {`);
+  lines.push("    fn default() -> Self {");
+
+  if (dispatch.defaultVariant) {
+    // Default to the wildcard/custom variant
+    const isSelfRef = dispatch.defaultVariant.isSelfReference;
+    const variantName = isSelfRef
+      ? "Custom"
+      : (dispatch.defaultVariant.typeName.name.replace(baseType.typeName.name, "") || "Custom");
+
+    const defaultType = childTypes.find(ct => ct.typeName.name === dispatch.defaultVariant!.typeName.name);
+    const variantFields = isSelfRef
+      ? []
+      : (defaultType
+          ? defaultType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+          : []);
+
+    if (variantFields.length === 0) {
+      lines.push(`        ${enumName}::${variantName} {`);
+      lines.push(`            ${toSnakeCase(dispatch.discriminatorField)}_name: String::new(),`);
+      lines.push("        }");
+    } else {
+      lines.push(`        ${enumName}::${variantName} {`);
+      for (const field of variantFields) {
+        lines.push(`            ${toSnakeCase(field.name)}: ${fieldDefault(field, polymorphicTypeNames)},`);
+      }
+      lines.push(`            ${toSnakeCase(dispatch.discriminatorField)}_name: String::new(),`);
+      lines.push("        }");
+    }
+  } else if (dispatch.variants.length > 0) {
+    // Default to the first named variant
+    const firstVariant = dispatch.variants[0];
+    const childType = childTypes.find(ct => ct.typeName.name === firstVariant.typeName.name);
+    const variantName = firstVariant.typeName.name.replace(baseType.typeName.name, "") || firstVariant.typeName.name;
+    const variantFields = childType
+      ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+      : [];
+
+    if (variantFields.length === 0) {
+      lines.push(`        ${enumName}::${variantName}`);
+    } else {
+      lines.push(`        ${enumName}::${variantName} {`);
+      for (const field of variantFields) {
+        lines.push(`            ${toSnakeCase(field.name)}: ${fieldDefault(field, polymorphicTypeNames)},`);
+      }
+      lines.push("        }");
+    }
+  }
+
+  lines.push("    }");
+  lines.push("}");
+}
+
+// ============================================================================
+// Struct Definition
+// ============================================================================
+
+function emitStruct(
+  type: TypeDecl,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  if (type.description) {
+    emitDocComment(type.description, "", lines);
+  }
+  if (type.wire) {
+    lines.push("#[derive(Debug, Clone, Default, serde::Serialize)]");
+    lines.push('#[serde(rename_all = "camelCase")]');
+  } else {
+    lines.push("#[derive(Debug, Clone, Default)]");
+  }
+  lines.push(`pub struct ${type.typeName.name} {`);
+
+  for (const field of type.fields) {
+    // Skip discriminator field — it's represented by the XxxKind enum field
+    if (type.polymorphicDispatch && field.name === type.polymorphicDispatch.discriminatorField) continue;
+    if (field.description) {
+      emitDocComment(field.description, "    ", lines);
+    }
+    lines.push(`    pub ${toSnakeCase(field.name)}: ${fieldType(field, polymorphicTypeNames)},`);
+  }
+
+  // Add kind field for polymorphic types
+  if (type.polymorphicDispatch) {
+    lines.push(`    /// Variant-specific data, discriminated by \`${type.polymorphicDispatch.discriminatorField}\`.`);
+    lines.push(`    pub ${toSnakeCase(type.polymorphicDispatch.discriminatorField)}: ${type.typeName.name}Kind,`);
+  }
+
+  lines.push("}");
+}
+
+// ============================================================================
+// Impl Block
+// ============================================================================
+
+function emitImpl(
+  type: TypeDecl,
+  childTypes: TypeDecl[],
+  baseFieldNames: Set<string>,
+  visitor: ExprVisitor,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const name = type.typeName.name;
+  lines.push("");
+  lines.push(`impl ${name} {`);
+
+  // new()
+  lines.push(`    /// Create a new ${name} with default values.`);
+  lines.push("    pub fn new() -> Self {");
+  lines.push("        Self::default()");
+  lines.push("    }");
+  lines.push("");
+
+  // from_json()
+  emitFromJson(name, lines);
+
+  // from_yaml()
+  emitFromYaml(name, lines);
+
+  // load_from_value()
+  emitLoadFromValue(name, type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+
+  // kind_str() for polymorphic types
+  if (type.polymorphicDispatch) {
+    emitKindStr(type, childTypes, lines);
+  }
+
+  // to_value()
+  emitToValue(name, type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+
+  // to_json() / to_yaml()
+  emitToJson(name, lines);
+  emitToYaml(name, lines);
+
+  // to_wire() (only when wire mappings exist)
+  if (type.wire) {
+    emitToWireMethod(type, lines);
+  }
+
+  // Dict accessor helpers (only for dict-category fields, not scalar value types)
+  for (const field of type.fields) {
+    if (field.category.kind === "dict") {
+      emitDictAccessor(field, lines);
+    }
+  }
+
+  // Collection helpers — include both base type and child type helpers
+  // (in Rust, child types are enum variants, so their helpers live on the parent impl)
+  const emittedHelpers = new Set<string>();
+  const allHelpers = [...type.collectionHelpers];
+  for (const child of childTypes) {
+    for (const h of child.collectionHelpers) {
+      if (!emittedHelpers.has(h.propertyName)) {
+        allHelpers.push(h);
+      }
+    }
+  }
+  for (const helper of allHelpers) {
+    if (emittedHelpers.has(helper.propertyName)) continue;
+    emittedHelpers.add(helper.propertyName);
+    emitCollectionLoadHelper(helper, polymorphicTypeNames, lines);
+    emitCollectionSaveHelper(helper, lines);
+  }
+
+  // Factories
+  for (const factory of type.factories) {
+    emitFactory(name, factory, visitor, lines);
+  }
+
+  lines.push("}");
+
+  // Method trait stubs (handled separately)
+}
+
+// ============================================================================
+// from_json / from_yaml
+// ============================================================================
+
+function emitFromJson(name: string, lines: string[]): void {
+  lines.push(`    /// Load ${name} from a JSON string.`);
+  lines.push(`    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {`);
+  lines.push("        let value: serde_json::Value = serde_json::from_str(json)?;");
+  lines.push("        Ok(Self::load_from_value(&value, ctx))");
+  lines.push("    }");
+  lines.push("");
+}
+
+function emitFromYaml(name: string, lines: string[]): void {
+  lines.push(`    /// Load ${name} from a YAML string.`);
+  lines.push(`    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {`);
+  lines.push("        let value: serde_json::Value = serde_yaml::from_str(yaml)?;");
+  lines.push("        Ok(Self::load_from_value(&value, ctx))");
+  lines.push("    }");
+  lines.push("");
+}
+
+// ============================================================================
+// load_from_value
+// ============================================================================
+
+function emitLoadFromValue(
+  name: string,
+  type: TypeDecl,
+  childTypes: TypeDecl[],
+  baseFieldNames: Set<string>,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  lines.push(`    /// Load ${name} from a \`serde_json::Value\`.`);
+  lines.push("    ///");
+  lines.push("    /// Calls `ctx.process_input` before field extraction.");
+  lines.push("    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {");
+  lines.push("        let value = ctx.process_input(value.clone());");
+
+  // Coercions
+  for (const c of type.load.coercions) {
+    emitCoercionBranch(name, c, type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+  }
+
+  // Polymorphic dispatch
+  if (type.polymorphicDispatch) {
+    emitPolymorphicLoad(name, type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+  } else {
+    // Simple struct construction
+    lines.push("        Self {");
+    for (const a of type.load.assignments) {
+      lines.push(`            ${toSnakeCase(a.fieldName)}: ${loadExpr(a, polymorphicTypeNames)},`);
+    }
+    lines.push("        }");
+  }
+
+  lines.push("    }");
+  lines.push("");
+}
+
+function emitCoercionBranch(
+  typeName: string,
+  c: CoercionDecl,
+  type: TypeDecl,
+  childTypes: TypeDecl[],
+  baseFieldNames: Set<string>,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const check = rustCoercionCheck(c.scalarType);
+  if (!check) return;
+
+  lines.push(`        ${check.ifLet} {`);
+
+  // For string coercions, rebind `s` → `value` so downstream references work
+  if (c.scalarType === "string") {
+    lines.push("            let value = s.to_string();");
+  }
+
+  const dispatch = type.polymorphicDispatch;
+  const discField = dispatch?.discriminatorField;
+  const enumName = typeName + "Kind";
+
+  // Build field assignments, handling discriminator → enum variant construction
+  const fieldAssignments = c.assignments.map(a => {
+    const snake = toSnakeCase(a.fieldName);
+    if (a.isInput) {
+      // Check if the target field is optional — wrap with Some() if so
+      const targetField = type.fields.find(f => f.name === a.fieldName);
+      const isOptional = targetField?.isOptional ?? false;
+      const expr = isOptional ? "Some(value.into())" : "value.into()";
+      return `${snake}: ${expr}`;
+    }
+    // Check if this field is the discriminator — must construct enum variant
+    if (dispatch && a.fieldName === discField) {
+      const discSnake = toSnakeCase(discField);
+      // Find if the literal matches a named variant
+      const matchingVariant = dispatch.variants.find(v => v.value === a.literalValue);
+      if (matchingVariant) {
+        const variantName = matchingVariant.typeName.name.replace(typeName, "") || matchingVariant.typeName.name;
+        // Check if variant has fields — unit variants don't get braces
+        const childType = childTypes.find(ct => ct.typeName.name === matchingVariant.typeName.name);
+        const variantFields = childType
+          ? childType.fields.filter(f => f.name !== dispatch!.discriminatorField && !baseFieldNames.has(f.name))
+          : [];
+        if (variantFields.length === 0) {
+          return `${discSnake}: ${enumName}::${variantName}`;
+        }
+        return `${discSnake}: ${enumName}::${variantName} { ..Default::default() }`;
+      }
+      // Otherwise use the wildcard/custom variant
+      if (dispatch.defaultVariant) {
+        const dvName = dispatch.defaultVariant.isSelfReference
+          ? "Custom"
+          : (dispatch.defaultVariant.typeName.name.replace(typeName, "") || "Custom");
+        return `${discSnake}: ${enumName}::${dvName} { ${discSnake}_name: "${a.literalValue}".to_string() }`;
+      }
+      return `${discSnake}: ${enumName}::default()`;
+    }
+    return `${snake}: "${a.literalValue}".to_string()`;
+  });
+
+  lines.push(`            return ${typeName} { ${fieldAssignments.join(", ")}, ..Default::default() };`);
+  lines.push("        }");
+}
+
+/**
+ * Get the Rust coercion check pattern for a scalar type.
+ */
+function rustCoercionCheck(scalarType: string): { ifLet: string } | null {
+  switch (scalarType) {
+    case "string":
+      return { ifLet: "if let Some(s) = value.as_str()" };
+    case "boolean":
+      return { ifLet: "if let Some(value) = value.as_bool()" };
+    case "float64":
+    case "float":
+    case "number":
+    case "numeric":
+      return { ifLet: "if let Some(value) = value.as_f64()" };
+    case "int32":
+    case "int64":
+    case "integer":
+      return { ifLet: "if let Some(value) = value.as_i64()" };
+    default:
+      return null;
+  }
+}
+
+/**
+ * Get the Rust expression to convert a coercion value to the target field type.
+ */
+function coercionIntoValue(scalarType: string): string {
+  // `value` is already bound in the coercion branch
+  // For string coercions: value is String, .into() for String → String
+  // For numeric/bool: value is the extracted primitive
+  return "value.into()";
+}
+
+function emitPolymorphicLoad(
+  name: string,
+  type: TypeDecl,
+  childTypes: TypeDecl[],
+  baseFieldNames: Set<string>,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const dispatch = type.polymorphicDispatch!;
+  const discSnake = toSnakeCase(dispatch.discriminatorField);
+  const enumName = name + "Kind";
+
+  lines.push(`        let ${discSnake}_str = value.get("${dispatch.discriminatorField}").and_then(|v| v.as_str()).unwrap_or("");`);
+  lines.push(`        let ${discSnake} = match ${discSnake}_str {`);
+
+  // Named variants
+  for (const variant of dispatch.variants) {
+    const childType = childTypes.find(ct => ct.typeName.name === variant.typeName.name);
+    const variantName = variant.typeName.name.replace(name, "") || variant.typeName.name;
+    const variantFields = childType
+      ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+      : [];
+
+    if (variantFields.length === 0) {
+      lines.push(`            "${variant.value}" => ${enumName}::${variantName},`);
+    } else {
+      lines.push(`            "${variant.value}" => ${enumName}::${variantName} {`);
+      for (const field of variantFields) {
+        const assignment = variantLoadExpr(field, name, polymorphicTypeNames);
+        lines.push(`                ${toSnakeCase(field.name)}: ${assignment},`);
+      }
+      lines.push(`            },`);
+    }
+  }
+
+  // Default / wildcard
+  if (dispatch.defaultVariant) {
+    const isSelfRef = dispatch.defaultVariant.isSelfReference;
+    const variantName = isSelfRef
+      ? "Custom"
+      : (dispatch.defaultVariant.typeName.name.replace(name, "") || "Custom");
+    const defaultType = childTypes.find(ct => ct.typeName.name === dispatch.defaultVariant!.typeName.name);
+    const variantFields = isSelfRef
+      ? []
+      : (defaultType
+          ? defaultType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+          : []);
+
+    if (variantFields.length === 0) {
+      lines.push(`            _ => ${enumName}::${variantName} {`);
+      lines.push(`                ${discSnake}_name: ${discSnake}_str.to_string(),`);
+      lines.push(`            },`);
+    } else {
+      lines.push(`            _ => ${enumName}::${variantName} {`);
+      for (const field of variantFields) {
+        const assignment = variantLoadExpr(field, name, polymorphicTypeNames);
+        lines.push(`                ${toSnakeCase(field.name)}: ${assignment},`);
+      }
+      lines.push(`                ${discSnake}_name: ${discSnake}_str.to_string(),`);
+      lines.push(`            },`);
+    }
+  } else {
+    lines.push(`            _ => ${enumName}::default(),`);
+  }
+
+  lines.push("        };");
+
+  // Construct the struct with base fields + kind
+  lines.push("        Self {");
+  for (const a of type.load.assignments) {
+    // Skip discriminator — it's stored in the enum field
+    if (a.fieldName === dispatch.discriminatorField) continue;
+    lines.push(`            ${toSnakeCase(a.fieldName)}: ${loadExpr(a, polymorphicTypeNames)},`);
+  }
+  lines.push(`            ${discSnake}: ${discSnake},`);
+  lines.push("        }");
+}
+
+// ============================================================================
+// kind_str
+// ============================================================================
+
+function emitKindStr(
+  type: TypeDecl,
+  childTypes: TypeDecl[],
+  lines: string[],
+): void {
+  const dispatch = type.polymorphicDispatch!;
+  const baseFieldNames = new Set(type.fields.map(f => f.name));
+  const enumName = type.typeName.name + "Kind";
+  const discSnake = toSnakeCase(dispatch.discriminatorField);
+
+  lines.push(`    /// Returns the \`${dispatch.discriminatorField}\` discriminator string for this instance.`);
+  lines.push(`    pub fn ${discSnake}_str(&self) -> &str {`);
+  lines.push(`        match &self.${discSnake} {`);
+
+  for (const variant of dispatch.variants) {
+    const variantName = variant.typeName.name.replace(type.typeName.name, "") || variant.typeName.name;
+    const childType = childTypes.find(ct => ct.typeName.name === variant.typeName.name);
+    const variantFields = childType
+      ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+      : [];
+    if (variantFields.length === 0) {
+      lines.push(`            ${enumName}::${variantName} => "${variant.value}",`);
+    } else {
+      lines.push(`            ${enumName}::${variantName} { .. } => "${variant.value}",`);
+    }
+  }
+
+  if (dispatch.defaultVariant) {
+    const isSelfRef = dispatch.defaultVariant.isSelfReference;
+    const variantName = isSelfRef
+      ? "Custom"
+      : (dispatch.defaultVariant.typeName.name.replace(type.typeName.name, "") || "Custom");
+    lines.push(`            ${enumName}::${variantName} { ${discSnake}_name, .. } => ${discSnake}_name.as_str(),`);
+  }
+
+  lines.push("        }");
+  lines.push("    }");
+  lines.push("");
+}
+
+// ============================================================================
+// to_value
+// ============================================================================
+
+function emitToValue(
+  name: string,
+  type: TypeDecl,
+  childTypes: TypeDecl[],
+  baseFieldNames: Set<string>,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  lines.push(`    /// Serialize ${name} to a \`serde_json::Value\`.`);
+  lines.push("    ///");
+  lines.push("    /// Calls `ctx.process_dict` after serialization.");
+  lines.push("    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {");
+  lines.push("        let mut result = serde_json::Map::new();");
+
+  // Write discriminator first
+  if (type.polymorphicDispatch) {
+    const discSnake = toSnakeCase(type.polymorphicDispatch.discriminatorField);
+    lines.push(`        // Write the discriminator`);
+    lines.push(`        result.insert("${type.polymorphicDispatch.discriminatorField}".to_string(), serde_json::Value::String(self.${discSnake}_str().to_string()));`);
+  }
+
+  // Write base fields
+  if (type.save.assignments.length > 0) {
+    lines.push(`        // Write base fields`);
+  }
+  for (const a of type.save.assignments) {
+    // Skip discriminator — it's written explicitly above from kind_str()
+    if (type.polymorphicDispatch && a.fieldName === type.polymorphicDispatch.discriminatorField) continue;
+    emitSaveField(a, "self.", polymorphicTypeNames, lines, "        ");
+  }
+
+  // Write variant-specific fields
+  if (type.polymorphicDispatch) {
+    emitVariantSave(type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+  }
+
+  lines.push("        ctx.process_dict(serde_json::Value::Object(result))");
+  lines.push("    }");
+  lines.push("");
+}
+
+function emitVariantSave(
+  type: TypeDecl,
+  childTypes: TypeDecl[],
+  baseFieldNames: Set<string>,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const dispatch = type.polymorphicDispatch!;
+  const enumName = type.typeName.name + "Kind";
+  const discSnake = toSnakeCase(dispatch.discriminatorField);
+
+  lines.push("        // Write variant-specific fields");
+  lines.push(`        match &self.${discSnake} {`);
+
+  for (const variant of dispatch.variants) {
+    const childType = childTypes.find(ct => ct.typeName.name === variant.typeName.name);
+    const variantName = variant.typeName.name.replace(type.typeName.name, "") || variant.typeName.name;
+    const variantFields = childType
+      ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+      : [];
+
+    if (variantFields.length === 0) {
+      lines.push(`            ${enumName}::${variantName} => {`);
+      lines.push("            }");
+    } else {
+      const destructure = variantFields.map(f => toSnakeCase(f.name)).join(", ");
+      lines.push(`            ${enumName}::${variantName} { ${destructure},  .. } => {`);
+      for (const field of variantFields) {
+        emitVariantSaveField(field, polymorphicTypeNames, type.typeName.name, lines);
+      }
+      lines.push("            }");
+    }
+  }
+
+  // Wildcard variant
+  if (dispatch.defaultVariant) {
+    const isSelfRef = dispatch.defaultVariant.isSelfReference;
+    const variantName = isSelfRef
+      ? "Custom"
+      : (dispatch.defaultVariant.typeName.name.replace(type.typeName.name, "") || "Custom");
+    const defaultType = childTypes.find(ct => ct.typeName.name === dispatch.defaultVariant!.typeName.name);
+    const variantFields = isSelfRef
+      ? []
+      : (defaultType
+          ? defaultType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+          : []);
+
+    if (variantFields.length === 0) {
+      lines.push(`            ${enumName}::${variantName} { ${discSnake}_name: _, .. } => {`);
+      lines.push("            }");
+    } else {
+      const destructure = variantFields.map(f => toSnakeCase(f.name)).join(", ");
+      lines.push(`            ${enumName}::${variantName} { ${destructure}, ${discSnake}_name: _, .. } => {`);
+      for (const field of variantFields) {
+        emitVariantSaveField(field, polymorphicTypeNames, type.typeName.name, lines);
+      }
+      lines.push("            }");
+    }
+  }
+
+  lines.push("        }");
+}
+
+// ============================================================================
+// to_json / to_yaml
+// ============================================================================
+
+function emitToJson(name: string, lines: string[]): void {
+  lines.push(`    /// Serialize ${name} to a JSON string.`);
+  lines.push(`    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {`);
+  lines.push("        serde_json::to_string_pretty(&self.to_value(ctx))");
+  lines.push("    }");
+  lines.push("");
+}
+
+function emitToYaml(name: string, lines: string[]): void {
+  lines.push(`    /// Serialize ${name} to a YAML string.`);
+  lines.push(`    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {`);
+  lines.push("        serde_yaml::to_string(&self.to_value(ctx))");
+  lines.push("    }");
+}
+
+// ============================================================================
+// to_wire — provider-specific wire format conversion
+// ============================================================================
+
+/**
+ * Emit a `to_wire(&self, provider: &str) -> serde_json::Value` method that
+ * serializes the struct via `serde_json::to_value`, then remaps field names
+ * according to provider-specific wire mappings.
+ *
+ * Only emitted when `type.wire` is non-null.
+ */
+function emitToWireMethod(type: TypeDecl, lines: string[]): void {
+  const wire = type.wire!;
+  const name = type.typeName.name;
+
+  lines.push("");
+  lines.push(`    /// Convert to provider-specific wire format.`);
+  lines.push(`    pub fn to_wire(&self, provider: &str) -> serde_json::Value {`);
+  lines.push(`        let data = serde_json::to_value(self).unwrap_or_default();`);
+  lines.push(`        let mut result = serde_json::Map::new();`);
+
+  // Build the wire_map HashMap literal
+  lines.push(
+    `        let wire_map: std::collections::HashMap<&str, std::collections::HashMap<&str, &str>> = std::collections::HashMap::from([`,
+  );
+  for (const mapping of wire.mappings) {
+    const entries = Object.entries(mapping.wireNames);
+    const inner = entries.map(([provider, wireName]) => `("${provider}", "${wireName}")`).join(", ");
+    lines.push(`            ("${mapping.fieldName}", std::collections::HashMap::from([${inner}])),`);
+  }
+  lines.push(`        ]);`);
+
+  // Iterate over serialized keys and remap (strict: only emit mapped fields)
+  lines.push(`        if let serde_json::Value::Object(map) = data {`);
+  lines.push(`            for (key, value) in map {`);
+  lines.push(`                if let Some(mapping) = wire_map.get(key.as_str()) {`);
+  lines.push(`                    if let Some(wire_name) = mapping.get(provider) {`);
+  lines.push(`                        result.insert(wire_name.to_string(), value);`);
+  lines.push(`                    }`);
+  lines.push(`                }`);
+  lines.push(`            }`);
+  lines.push(`        }`);
+  lines.push(`        serde_json::Value::Object(result)`);
+  lines.push(`    }`);
+}
+
+// ============================================================================
+// Dict accessor helpers
+// ============================================================================
+
+function emitDictAccessor(field: FieldDecl, lines: string[]): void {
+  const snake = toSnakeCase(field.name);
+  lines.push(`    /// Returns typed reference to the map if the field is an object.`);
+  lines.push(`    /// Returns \`None\` if the field is null or not an object.`);
+  lines.push(`    pub fn as_${snake}_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {`);
+  lines.push(`        self.${snake}.as_object()`);
+  lines.push("    }");
+  lines.push("");
+}
+
+// ============================================================================
+// Collection helpers
+// ============================================================================
+
+function emitCollectionLoadHelper(
+  helper: CollectionHelperDecl,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+): void {
+  const fnName = `load_${toSnakeCase(helper.propertyName)}`;
+  const elemType = helper.elementTypeName.name;
+
+  lines.push("");
+  lines.push(`    /// Load a collection of ${elemType} from a JSON value.`);
+  if (helper.hasNameProperty) {
+    lines.push(`    /// Handles both array format \`[{...}]\` and dict format \`{"name": {...}}\`.`);
+  } else {
+    lines.push(`    /// Handles both array format \`[{...}]\`.`);
+  }
+  lines.push(`    fn ${fnName}(data: &serde_json::Value, ctx: &LoadContext) -> Vec<${elemType}> {`);
+  lines.push("        match data {");
+  lines.push("            serde_json::Value::Array(arr) => {");
+  lines.push(`                arr.iter().map(|v| ${elemType}::load_from_value(v, ctx)).collect()`);
+  lines.push("            }");
+  lines.push("");
+
+  if (helper.hasNameProperty) {
+    // Dict format with name keys
+    const shorthandField = helper.innerFields.length > 0 ? helper.innerFields[0] : "value";
+    lines.push("            serde_json::Value::Object(obj) => {");
+    lines.push("                obj.iter()");
+    lines.push("                    .filter_map(|(name, value)| {");
+    lines.push("                        if value.is_array() {");
+    lines.push("                            return None;");
+    lines.push("                        }");
+    lines.push("                        let mut v = if value.is_object() {");
+    lines.push("                            value.clone()");
+    lines.push("                        } else {");
+    lines.push(`                            serde_json::json!({ "${shorthandField}": value })`);
+    lines.push("                        };");
+    lines.push('                        if let serde_json::Value::Object(ref mut m) = v {');
+    lines.push('                            m.entry("name".to_string()).or_insert_with(|| serde_json::Value::String(name.clone()));');
+    lines.push("                        }");
+    lines.push(`                        Some(${elemType}::load_from_value(&v, ctx))`);
+    lines.push("                    })");
+    lines.push("                    .collect()");
+    lines.push("            }");
+  }
+
+  lines.push("            _ => Vec::new(),");
+  lines.push("");
+  lines.push("        }");
+  lines.push("    }");
+  lines.push("");
+
+  // Save helper
+}
+
+function emitCollectionSaveHelper(
+  helper: CollectionHelperDecl,
+  lines: string[],
+): void {
+  const fnName = `save_${toSnakeCase(helper.propertyName)}`;
+  const elemType = helper.elementTypeName.name;
+
+  lines.push(`    /// Save a collection of ${elemType} to a JSON value.`);
+  lines.push(`    fn ${fnName}(items: &[${elemType}], ctx: &SaveContext) -> serde_json::Value {`);
+
+  if (helper.hasNameProperty) {
+    lines.push("");
+    lines.push('        if ctx.collection_format == "array" {');
+    lines.push("            return serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>());");
+    lines.push("        }");
+    lines.push("        // Object format: use name as key");
+    lines.push("        let mut result = serde_json::Map::new();");
+    lines.push("        for item in items {");
+    lines.push("            let mut item_data = match item.to_value(ctx) {");
+    lines.push('                serde_json::Value::Object(m) => m,');
+    lines.push('                other => { let mut m = serde_json::Map::new(); m.insert("value".to_string(), other); m },');
+    lines.push("            };");
+    lines.push('            if let Some(serde_json::Value::String(name)) = item_data.remove("name") {');
+    lines.push("                result.insert(name, serde_json::Value::Object(item_data));");
+    lines.push("            }");
+    lines.push("        }");
+    lines.push("        serde_json::Value::Object(result)");
+  } else {
+    lines.push("");
+    lines.push("        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())");
+  }
+
+  lines.push("");
+  lines.push("    }");
+}
+
+// ============================================================================
+// Factory methods
+// ============================================================================
+
+function emitFactory(
+  parentName: string,
+  factory: FactoryDecl,
+  visitor: ExprVisitor,
+  lines: string[],
+): void {
+  const params = Object.entries(factory.params)
+    .map(([pName, pType]) => `${toSnakeCase(pName)}: ${factoryParamType(pType)}`)
+    .join(", ");
+
+  lines.push(`    /// Create a ${parentName} with preset field values.`);
+  lines.push(`    pub fn ${factory.name}(${params}) -> Self {`);
+  lines.push(`        ${visitor.visitExpr(factory.body)}`);
+  lines.push("    }");
+}
+
+function factoryParamType(typeStr: string): string {
+  switch (typeStr) {
+    case "string":
+      return "impl Into<String>";
+    case "unknown":
+    case "any":
+      return "impl Into<serde_json::Value>";
+    case "boolean":
+      return "bool";
+    case "int32":
+      return "i32";
+    case "int64":
+    case "integer":
+      return "i64";
+    case "float32":
+      return "f32";
+    case "float64":
+    case "float":
+      return "f64";
+    default:
+      return `impl Into<${typeStr}>`;
+  }
+}
+
+// ============================================================================
+// Method stub trait
+// ============================================================================
+
+function emitMethodTrait(type: TypeDecl, lines: string[]): void {
+  lines.push(`/// Helpers for [\`${type.typeName.name}\`]. Implement in a separate file.`);
+  lines.push(`pub trait ${type.typeName.name}Helpers {`);
+  for (const method of type.methods) {
+    if (method.description) {
+      emitDocComment(method.description, "    ", lines);
+    }
+    lines.push(`    fn ${toSnakeCase(method.name)}(&self) -> ${methodReturnType(method)};`);
+  }
+  lines.push("}");
+}
+
+function methodReturnType(method: MethodStubDecl): string {
+  if (method.returns === "string") return "String";
+  return RUST_TYPE_MAP[method.returns] || method.returns;
+}
+
+// ============================================================================
+// Protocol trait emission
+// ============================================================================
+
+/** Map a protocol type string to a Rust type. */
+function protocolRustType(typeStr: string): string {
+  // Handle nullable types
+  if (typeStr.endsWith("?")) {
+    const inner = typeStr.slice(0, -1);
+    return `Option<${protocolRustType(inner)}>`;
+  }
+  // Handle array types
+  if (typeStr.endsWith("[]")) {
+    const inner = typeStr.slice(0, -2);
+    return `Vec<${protocolRustType(inner)}>`;
+  }
+  if (typeStr === "Record<unknown>" || typeStr === "dictionary") return "serde_json::Value";
+  if (typeStr === "unknown" || typeStr === "any") return "serde_json::Value";
+  if (typeStr === "string") return "String";
+  return RUST_TYPE_MAP[typeStr] || typeStr;
+}
+
+/**
+ * Emit a Rust trait for a protocol type.
+ * Uses #[async_trait] for async method support.
+ */
+function emitProtocolTrait(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+
+  if (type.description) {
+    emitDocComment(type.description, "", lines);
+  }
+  lines.push("#[async_trait::async_trait]");
+  lines.push(`pub trait ${name}: Send + Sync {`);
+
+  for (const method of type.methods) {
+    if (method.description) {
+      emitDocComment(method.description, "    ", lines);
+    }
+    const params = Object.entries(method.params)
+      .map(([pName, pType]) => `${toSnakeCase(pName)}: &${protocolRustType(pType)}`)
+      .join(", ");
+    const ret = protocolRustType(method.returns);
+
+    if (method.sync) {
+      // Synchronous method
+      if (method.optional) {
+        // Return type already includes nullability from ? suffix — don't double-wrap
+        lines.push(`    fn ${toSnakeCase(method.name)}(&self, ${params}) -> ${ret} {`);
+        lines.push("        None");
+        lines.push("    }");
+      } else {
+        lines.push(`    fn ${toSnakeCase(method.name)}(&self, ${params}) -> ${ret};`);
+      }
+    } else {
+      // Async method
+      if (method.optional) {
+        // Default implementation returns an error — providers override with real streaming
+        lines.push(`    async fn ${toSnakeCase(method.name)}(&self, ${params}) -> Result<${ret}, Box<dyn std::error::Error + Send + Sync>> {`);
+        lines.push(`        Err("not supported".into())`);
+        lines.push("    }");
+      } else {
+        lines.push(`    async fn ${toSnakeCase(method.name)}(&self, ${params}) -> Result<${ret}, Box<dyn std::error::Error + Send + Sync>>;`);
+      }
+    }
+  }
+
+  lines.push("}");
+}
+
+// ============================================================================
+// Field type rendering
+// ============================================================================
+
+function fieldType(field: FieldDecl, polymorphicTypeNames: Set<string>): string {
+  const cat = field.category;
+  switch (cat.kind) {
+    case "scalar": {
+      const rustType = RUST_TYPE_MAP[cat.scalarType] || cat.scalarType;
+      // dict category handles always-Value separately; for scalar value types
+      // (any, object, unknown), optional fields are Option<Value>, required are Value.
+      // dictionary scalar is always Value (never Option) since it's a map type.
+      if (cat.scalarType === "dictionary") {
+        return "serde_json::Value";
+      }
+      return field.isOptional ? `Option<${rustType}>` : rustType;
+    }
+    case "complex": {
+      // Polymorphic references and "unknown" become serde_json::Value
+      // Always non-optional — Value::Null serves as the "absent" sentinel
+      if (polymorphicTypeNames.has(cat.typeName) || cat.typeName === "unknown") {
+        return "serde_json::Value";
+      }
+      return field.isOptional ? `Option<${cat.typeName}>` : cat.typeName;
+    }
+    case "collection_scalar": {
+      const elemType = RUST_TYPE_MAP[cat.scalarType] || cat.scalarType;
+      if (isValueType(cat.scalarType)) {
+        return field.isOptional ? "Option<Vec<serde_json::Value>>" : "Vec<serde_json::Value>";
+      }
+      return field.isOptional ? `Option<Vec<${elemType}>>` : `Vec<${elemType}>`;
+    }
+    case "collection_complex": {
+      if (cat.typeName === "unknown") {
+        return "Vec<serde_json::Value>";
+      }
+      return `Vec<${cat.typeName}>`;
+    }
+    case "dict": {
+      return "serde_json::Value";
+    }
+  }
+}
+
+function isValueType(scalarType: string): boolean {
+  return scalarType === "any" || scalarType === "object" || scalarType === "dictionary" || scalarType === "unknown";
+}
+
+function fieldDefault(field: FieldDecl, polymorphicTypeNames: Set<string>): string {
+  const cat = field.category;
+  switch (cat.kind) {
+    case "scalar": {
+      if (isValueType(cat.scalarType)) {
+        // dictionary is always Value (never Option); other value types may be optional
+        if (cat.scalarType !== "dictionary" && field.isOptional) return "None";
+        return "serde_json::Value::Null";
+      }
+      if (field.isOptional) return "None";
+      const rustType = RUST_TYPE_MAP[cat.scalarType] || cat.scalarType;
+      if (rustType === "String") return 'String::from("")';
+      if (rustType === "bool") return "false";
+      if (rustType === "i32" || rustType === "i64") return "0";
+      if (rustType === "f32" || rustType === "f64") return "0.0";
+      return "Default::default()";
+    }
+    case "complex": {
+      // Polymorphic refs are always serde_json::Value, Null is the "absent" sentinel
+      if (polymorphicTypeNames.has(cat.typeName)) return "serde_json::Value::Null";
+      return field.isOptional ? "None" : "Default::default()";
+    }
+    case "collection_scalar":
+    case "collection_complex":
+      return field.isOptional ? "None" : "Vec::new()";
+    case "dict":
+      return "serde_json::Value::Null";
+  }
+}
+
+// ============================================================================
+// Load expression rendering (per-field)
+// ============================================================================
+
+function loadExpr(a: LoadAssignment, polymorphicTypeNames: Set<string>): string {
+  const key = a.sourceName;
+  const cat = a.category;
+
+  switch (cat.kind) {
+    case "scalar":
+      return scalarLoadExpr(key, cat.scalarType, a.isOptional);
+    case "complex": {
+      if (polymorphicTypeNames.has(cat.typeName)) {
+        // Polymorphic ref → always serde_json::Value, Null is the "absent" sentinel
+        return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+      }
+      if (a.isOptional) {
+        return `value.get("${key}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ${cat.typeName}::load_from_value(v, ctx))`;
+      }
+      return `value.get("${key}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ${cat.typeName}::load_from_value(v, ctx)).unwrap_or_default()`;
+    }
+    case "collection_scalar":
+      return collectionScalarLoadExpr(key, cat.scalarType, a.isOptional);
+    case "collection_complex":
+      return `value.get("${key}").map(|v| Self::load_${toSnakeCase(a.fieldName)}(v, ctx)).unwrap_or_default()`;
+    case "dict":
+      return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+  }
+}
+
+function scalarLoadExpr(key: string, scalarType: string, isOptional: boolean): string {
+  if (isValueType(scalarType)) {
+    // dictionary is never optional; any/object/unknown may be optional
+    if (scalarType === "dictionary") {
+      return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+    }
+    return isOptional
+      ? `value.get("${key}").cloned()`
+      : `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+  }
+
+  switch (scalarType) {
+    case "string":
+      return isOptional
+        ? `value.get("${key}").and_then(|v| v.as_str()).map(|s| s.to_string())`
+        : `value.get("${key}").and_then(|v| v.as_str()).unwrap_or_default().to_string()`;
+    case "boolean":
+      return isOptional
+        ? `value.get("${key}").and_then(|v| v.as_bool())`
+        : `value.get("${key}").and_then(|v| v.as_bool()).unwrap_or(false)`;
+    case "int32":
+      return isOptional
+        ? `value.get("${key}").and_then(|v| v.as_i64()).map(|v| v as i32)`
+        : `value.get("${key}").and_then(|v| v.as_i64()).unwrap_or(0) as i32`;
+    case "int64":
+    case "integer":
+      return isOptional
+        ? `value.get("${key}").and_then(|v| v.as_i64())`
+        : `value.get("${key}").and_then(|v| v.as_i64()).unwrap_or(0)`;
+    case "float64":
+    case "float":
+    case "number":
+    case "numeric":
+      return isOptional
+        ? `value.get("${key}").and_then(|v| v.as_f64())`
+        : `value.get("${key}").and_then(|v| v.as_f64()).unwrap_or(0.0)`;
+    case "float32":
+      return isOptional
+        ? `value.get("${key}").and_then(|v| v.as_f64()).map(|v| v as f32)`
+        : `value.get("${key}").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32`;
+    default:
+      return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+  }
+}
+
+function collectionScalarLoadExpr(key: string, scalarType: string, isOptional: boolean): string {
+  if (isValueType(scalarType)) {
+    return isOptional
+      ? `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.to_vec())`
+      : `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.to_vec()).unwrap_or_default()`;
+  }
+
+  switch (scalarType) {
+    case "string":
+      return isOptional
+        ? `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect())`
+        : `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()).unwrap_or_default()`;
+    default:
+      return isOptional
+        ? `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.to_vec())`
+        : `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.to_vec()).unwrap_or_default()`;
+  }
+}
+
+/**
+ * Load expression for a variant field (used inside match arms).
+ */
+function variantLoadExpr(
+  field: FieldDecl,
+  parentTypeName: string,
+  polymorphicTypeNames: Set<string>,
+): string {
+  // Delegate to the same patterns as base field loading, but with "value" as the source
+  const key = field.name;
+  const cat = field.category;
+
+  switch (cat.kind) {
+    case "scalar":
+      return scalarLoadExpr(key, cat.scalarType, field.isOptional);
+    case "complex": {
+      if (polymorphicTypeNames.has(cat.typeName)) {
+        return field.isOptional
+          ? `value.get("${key}").cloned()`
+          : `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+      }
+      if (field.isOptional) {
+        return `value.get("${key}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ${cat.typeName}::load_from_value(v, ctx))`;
+      }
+      return `value.get("${key}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ${cat.typeName}::load_from_value(v, ctx)).unwrap_or_default()`;
+    }
+    case "collection_scalar":
+      return collectionScalarLoadExpr(key, cat.scalarType, field.isOptional);
+    case "collection_complex":
+      // Collection in a variant — use the parent type's helper
+      return `value.get("${key}").map(|v| Self::load_${toSnakeCase(field.name)}(v, ctx)).unwrap_or_default()`;
+    case "dict":
+      return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+  }
+}
+
+// ============================================================================
+// Save expression rendering (per-field)
+// ============================================================================
+
+function emitSaveField(
+  a: SaveAssignment,
+  prefix: string,
+  polymorphicTypeNames: Set<string>,
+  lines: string[],
+  indent: string,
+): void {
+  const key = a.targetName;
+  const fieldRef = `${prefix}${toSnakeCase(a.fieldName)}`;
+  const cat = a.category;
+
+  switch (cat.kind) {
+    case "scalar":
+      emitScalarSave(key, fieldRef, cat.scalarType, a.isOptional, lines, indent);
+      return;
+    case "complex": {
+      if (polymorphicTypeNames.has(cat.typeName)) {
+        // Polymorphic ref → always serde_json::Value, check .is_null()
+        lines.push(`${indent}if !${fieldRef}.is_null() {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+        lines.push(`${indent}}`);
+        return;
+      }
+      if (a.isOptional) {
+        lines.push(`${indent}if let Some(ref val) = ${fieldRef} {`);
+        lines.push(`${indent}    let nested = val.to_value(ctx);`);
+        lines.push(`${indent}    if !nested.is_null() {`);
+        lines.push(`${indent}        result.insert("${key}".to_string(), nested);`);
+        lines.push(`${indent}    }`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}{`);
+        lines.push(`${indent}    let nested = ${fieldRef}.to_value(ctx);`);
+        lines.push(`${indent}    if !nested.is_null() {`);
+        lines.push(`${indent}        result.insert("${key}".to_string(), nested);`);
+        lines.push(`${indent}    }`);
+        lines.push(`${indent}}`);
+      }
+      return;
+    }
+    case "collection_scalar": {
+      if (a.isOptional) {
+        lines.push(`${indent}if let Some(ref items) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::to_value(&${fieldRef}).unwrap_or(serde_json::Value::Null));`);
+        lines.push(`${indent}}`);
+      }
+      return;
+    }
+    case "collection_complex": {
+      lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+      lines.push(`${indent}    result.insert("${key}".to_string(), Self::save_${toSnakeCase(a.fieldName)}(&${fieldRef}, ctx));`);
+      lines.push(`${indent}}`);
+      return;
+    }
+    case "dict": {
+      lines.push(`${indent}if !${fieldRef}.is_null() {`);
+      lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+      lines.push(`${indent}}`);
+      return;
+    }
+  }
+}
+
+function emitScalarSave(
+  key: string,
+  fieldRef: string,
+  scalarType: string,
+  isOptional: boolean,
+  lines: string[],
+  indent: string,
+): void {
+  if (isValueType(scalarType)) {
+    if (scalarType !== "dictionary" && isOptional) {
+      // Optional value types (any, object, unknown) are Option<Value>
+      lines.push(`${indent}if let Some(ref val) = ${fieldRef} {`);
+      lines.push(`${indent}    result.insert("${key}".to_string(), val.clone());`);
+      lines.push(`${indent}}`);
+    } else {
+      // Required value types or dictionary (always Value, never Option)
+      lines.push(`${indent}if !${fieldRef}.is_null() {`);
+      lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+      lines.push(`${indent}}`);
+    }
+    return;
+  }
+
+  switch (scalarType) {
+    case "string":
+      if (isOptional) {
+        lines.push(`${indent}if let Some(ref val) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(val.clone()));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(${fieldRef}.clone()));`);
+        lines.push(`${indent}}`);
+      }
+      return;
+    case "boolean":
+      if (isOptional) {
+        lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Bool(val));`);
+        lines.push(`${indent}}`);
+      } else {
+        // Always write booleans
+        lines.push(`${indent}result.insert("${key}".to_string(), serde_json::Value::Bool(${fieldRef}));`);
+      }
+      return;
+    case "int32":
+    case "int64":
+    case "integer":
+      if (isOptional) {
+        lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}if ${fieldRef} != 0 {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Number(serde_json::Number::from(${fieldRef})));`);
+        lines.push(`${indent}}`);
+      }
+      return;
+    case "float32":
+    case "float64":
+    case "float":
+    case "number":
+    case "numeric":
+      if (isOptional) {
+        lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Number::from_f64(val as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}if ${fieldRef} != 0.0 {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Number::from_f64(${fieldRef} as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));`);
+        lines.push(`${indent}}`);
+      }
+      return;
+  }
+}
+
+/**
+ * Emit a save expression for a variant field (destructured in a match arm).
+ */
+function emitVariantSaveField(
+  field: FieldDecl,
+  polymorphicTypeNames: Set<string>,
+  parentTypeName: string,
+  lines: string[],
+): void {
+  const key = field.name;
+  const fieldRef = toSnakeCase(field.name);
+  const cat = field.category;
+  const indent = "                ";
+
+  switch (cat.kind) {
+    case "scalar":
+      emitVariantScalarSave(key, fieldRef, cat.scalarType, field.isOptional, lines, indent);
+      return;
+    case "complex": {
+      if (polymorphicTypeNames.has(cat.typeName)) {
+        if (field.isOptional) {
+          lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+          lines.push(`${indent}    result.insert("${key}".to_string(), val.clone());`);
+          lines.push(`${indent}}`);
+        } else {
+          lines.push(`${indent}if !${fieldRef}.is_null() {`);
+          lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+          lines.push(`${indent}}`);
+        }
+        return;
+      }
+      if (field.isOptional) {
+        lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), val.to_value(ctx));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}{`);
+        lines.push(`${indent}    let nested = ${fieldRef}.to_value(ctx);`);
+        lines.push(`${indent}    if !nested.is_null() {`);
+        lines.push(`${indent}        result.insert("${key}".to_string(), nested);`);
+        lines.push(`${indent}    }`);
+        lines.push(`${indent}}`);
+      }
+      return;
+    }
+    case "collection_scalar": {
+      if (field.isOptional) {
+        lines.push(`${indent}if let Some(items) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::to_value(${fieldRef}).unwrap_or(serde_json::Value::Null));`);
+        lines.push(`${indent}}`);
+      }
+      return;
+    }
+    case "collection_complex": {
+      lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+      lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Array(${fieldRef}.iter().map(|item| item.to_value(ctx)).collect()));`);
+      lines.push(`${indent}}`);
+      return;
+    }
+    case "dict": {
+      lines.push(`${indent}if !${fieldRef}.is_null() {`);
+      lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+      lines.push(`${indent}}`);
+      return;
+    }
+  }
+}
+
+function emitVariantScalarSave(
+  key: string,
+  fieldRef: string,
+  scalarType: string,
+  isOptional: boolean,
+  lines: string[],
+  indent: string,
+): void {
+  if (isValueType(scalarType)) {
+    if (scalarType !== "dictionary" && isOptional) {
+      // Optional value types — variant fields are references, use direct pattern
+      lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+      lines.push(`${indent}    result.insert("${key}".to_string(), val.clone());`);
+      lines.push(`${indent}}`);
+    } else {
+      lines.push(`${indent}if !${fieldRef}.is_null() {`);
+      lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+      lines.push(`${indent}}`);
+    }
+    return;
+  }
+
+  switch (scalarType) {
+    case "string":
+      if (isOptional) {
+        lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(val.clone()));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(${fieldRef}.clone()));`);
+        lines.push(`${indent}}`);
+      }
+      return;
+    case "boolean":
+      if (isOptional) {
+        lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Bool(*val));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}result.insert("${key}".to_string(), serde_json::Value::Bool(*${fieldRef}));`);
+      }
+      return;
+    case "int32":
+    case "int64":
+    case "integer":
+      if (isOptional) {
+        lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Number(serde_json::Number::from(*val)));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}if *${fieldRef} != 0 {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Number(serde_json::Number::from(*${fieldRef})));`);
+        lines.push(`${indent}}`);
+      }
+      return;
+    case "float32":
+    case "float64":
+    case "float":
+    case "number":
+    case "numeric":
+      if (isOptional) {
+        lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Number::from_f64(*val as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));`);
+        lines.push(`${indent}}`);
+      } else {
+        lines.push(`${indent}if *${fieldRef} != 0.0 {`);
+        lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Number::from_f64(*${fieldRef} as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));`);
+        lines.push(`${indent}}`);
+      }
+      return;
+  }
+}
diff --git a/schema/emitter/src/languages/rust/visitor.ts b/schema/emitter/src/languages/rust/visitor.ts
new file mode 100644
index 00000000..d6686f56
--- /dev/null
+++ b/schema/emitter/src/languages/rust/visitor.ts
@@ -0,0 +1,156 @@
+/**
+ * Rust expression visitor — Expr IR → Rust source fragments.
+ */
+
+import { Expr, FieldAssignment, Construct, VariantConstruct, ArrayLiteral, FieldRead, TypeRegistry } from "../../ir/expansion.js";
+import { ExprVisitor, assertNever } from "../../ir/visitor.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+
+export class RustExprVisitor implements ExprVisitor {
+  registry?: TypeRegistry;
+
+  constructor(registry?: TypeRegistry) {
+    this.registry = registry;
+  }
+
+  visitExpr(expr: Expr): string {
+    switch (expr.kind) {
+      case "string":
+        return `"${this.escapeString(expr.value)}".to_string()`;
+      case "number":
+        return String(expr.value);
+      case "boolean":
+        return expr.value ? "true" : "false";
+      case "null":
+        return "None";
+      case "param":
+        // Always use .into() in Rust — handles String→String, bool→Value, i64→Value, etc.
+        return `${toSnakeCase(expr.name)}.into()`;
+      case "construct":
+        return this.visitConstruct(expr);
+      case "variant":
+        return this.visitVariant(expr);
+      case "array":
+        return this.visitArray(expr);
+      case "dict":
+        return `serde_json::json!({${expr.entries.map(e => `"${e.key}": ${this.visitExpr(e.value)}`).join(", ")}})`;
+      case "field_read":
+        return this.visitFieldRead(expr);
+      default:
+        return assertNever(expr);
+    }
+  }
+
+  private visitConstruct(expr: Construct): string {
+    const typeName = expr.typeName.name;
+
+    // Check if this is a polymorphic type — discriminator fields need enum variant wrapping
+    const typeNode = this.registry?.get(typeName);
+    if (typeNode?.discriminator && typeNode.childTypes.length > 0) {
+      return this.visitPolymorphicConstruct(expr, typeNode);
+    }
+
+    if (expr.fields.length === 0) {
+      return `${typeName} { ..Default::default() }`;
+    }
+    const fields = expr.fields.map(f =>
+      `${toSnakeCase(f.propertyName)}: ${this.wrapFieldValue(f)}`
+    ).join(", ");
+    return `${typeName} { ${fields}, ..Default::default() }`;
+  }
+
+  /**
+   * Handle Construct on a polymorphic type — the discriminator field becomes an enum variant.
+   * E.g., Property { kind: "boolean", example: v } → Property { kind: PropertyKind::Custom { kind_name: "boolean".to_string() }, example: Some(v.into()), ..Default::default() }
+   */
+  private visitPolymorphicConstruct(expr: Construct, typeNode: import("../../ir/ast.js").TypeNode): string {
+    const typeName = expr.typeName.name;
+    const enumName = `${typeName}Kind`;
+    const discFieldName = typeNode.discriminator!;
+
+    // Find the discriminator field assignment
+    const discField = expr.fields.find(f => f.propertyName === discFieldName);
+    const discValue = discField?.value;
+
+    // If no discriminator field or not a string literal, fall back to normal construction
+    if (!discField || discValue?.kind !== "string") {
+      const fields = expr.fields.map(f =>
+        `${toSnakeCase(f.propertyName)}: ${this.wrapFieldValue(f)}`
+      ).join(", ");
+      return fields.length > 0
+        ? `${typeName} { ${fields}, ..Default::default() }`
+        : `${typeName} { ..Default::default() }`;
+    }
+
+    const discValueStr = discValue.value;
+
+    // Find matching named child type
+    const childType = typeNode.childTypes.find(child => {
+      const dp = child.properties.find((p: any) => p.name === discFieldName);
+      return dp?.defaultValue === discValueStr;
+    });
+
+    let kindValue: string;
+    if (childType) {
+      // Named variant (e.g., PropertyKind::Array)
+      const variantName = childType.typeName.name.replace(typeName, '') || childType.typeName.name;
+      kindValue = `${enumName}::${variantName}`;
+    } else {
+      // Wildcard/Custom variant — carries kind_name field
+      kindValue = `${enumName}::Custom { kind_name: "${discValueStr}".to_string() }`;
+    }
+
+    // Non-discriminator fields
+    const baseFields = expr.fields
+      .filter(f => f.propertyName !== discFieldName)
+      .map(f => `${toSnakeCase(f.propertyName)}: ${this.wrapFieldValue(f)}`);
+
+    const allFields = [
+      `${toSnakeCase(discFieldName)}: ${kindValue}`,
+      ...baseFields,
+    ];
+
+    return `${typeName} { ${allFields.join(", ")}, ..Default::default() }`;
+  }
+
+  private visitVariant(expr: VariantConstruct): string {
+    const baseName = expr.baseTypeName.name;
+    const variantName = expr.variantTypeName.name;
+    const enumName = `${baseName}Kind`;
+    const fields = expr.fields.map(f =>
+      `${toSnakeCase(f.propertyName)}: ${this.wrapFieldValue(f)}`
+    ).join(", ");
+    const kindValue = fields.length > 0
+      ? `${enumName}::${variantName} { ${fields} }`
+      : `${enumName}::${variantName}`;
+    return `${baseName} { ${toSnakeCase(expr.discriminator)}: ${kindValue}, ..Default::default() }`;
+  }
+
+  private visitArray(expr: ArrayLiteral): string {
+    if (expr.items.length === 0) {
+      return "vec![]";
+    }
+    const items = expr.items.map(i => this.visitExpr(i)).join(", ");
+    return `vec![${items}]`;
+  }
+
+  /**
+   * Wrap field values appropriately for Rust — Option<T> fields need Some(),
+   * string fields need .into(), etc.
+   */
+  private wrapFieldValue(field: FieldAssignment): string {
+    const inner = this.visitExpr(field.value);
+    if (field.isOptional) {
+      return `Some(${inner})`;
+    }
+    return inner;
+  }
+
+  private escapeString(s: string): string {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+
+  private visitFieldRead(expr: FieldRead): string {
+    return `${toSnakeCase(expr.objectName)}.${toSnakeCase(expr.fieldName)}`;
+  }
+}
diff --git a/schema/emitter/src/languages/typescript/driver.ts b/schema/emitter/src/languages/typescript/driver.ts
new file mode 100644
index 00000000..28427388
--- /dev/null
+++ b/schema/emitter/src/languages/typescript/driver.ts
@@ -0,0 +1,190 @@
+import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
+import { EmitTarget, PromptyEmitterOptions } from "../../lib.js";
+import { enumerateTypes, TypeNode, BaseTestContext } from "../../ir/ast.js";
+import { GeneratorOptions, filterNodes } from "../../emitter.js";
+import { TypeRegistry } from "../../ir/expansion.js";
+import { TypeScriptExprVisitor } from "./visitor.js";
+import { emitTypeScriptFile as emitTypeScriptFileDecl } from "./emitter.js";
+import { emitTypeScriptContext, emitTypeScriptIndex, emitEslintConfig } from "./scaffolding.js";
+import { emitTypeScriptTest } from "./test-emitter.js";
+import { lowerFile, collectPolymorphicTypeNames } from "../../ir/lower.js";
+import { buildBaseTestContext, typescriptTestOptions } from "../../testing/test-context.js";
+import { toKebabCase } from "../../ir/utilities.js";
+import { resolve, dirname } from "path";
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+
+/**
+ * Generate TypeScript code from TypeSpec models.
+ */
+export const generateTypeScript = async (
+  context: EmitContext<PromptyEmitterOptions>,
+  node: TypeNode,
+  emitTarget: EmitTarget,
+  options?: GeneratorOptions
+) => {
+  const allTypes = Array.from(enumerateTypes(node));
+  const nodes = filterNodes(allTypes, options);
+
+  // Build the expression IR infrastructure
+  const registry = TypeRegistry.fromTypeGraph(allTypes);
+  const visitor = new TypeScriptExprVisitor(registry);
+
+  // Determine namespace: use override or default
+  const originalNamespace = node.typeName.namespace;
+  const tsNamespace = emitTarget.namespace ?? originalNamespace.replace(/\.Core$/, "");
+
+  // Emit context classes (LoadContext, SaveContext)
+  const contextCode = emitTypeScriptContext();
+  await emitTypeScriptFile(context, "context.ts", contextCode, emitTarget["output-dir"]);
+
+  // Collect polymorphic type names once for the full type graph
+  const polymorphicTypeNames = new Set<string>();
+  for (const n of allTypes) {
+    for (const name of collectPolymorphicTypeNames(n, registry)) {
+      polymorphicTypeNames.add(name);
+    }
+  }
+
+  // Emit each base type file (includes children in the same file)
+  for (const n of nodes) {
+    // Skip child types - they're rendered with their parent
+    if (n.base) {
+      continue;
+    }
+
+    const fileDecl = lowerFile(n, registry, polymorphicTypeNames);
+    const code = emitTypeScriptFileDecl(fileDecl, visitor, tsNamespace);
+    await emitTypeScriptFile(context, `${toKebabCase(n.typeName.name)}.ts`, code, emitTarget["output-dir"]);
+  }
+
+  // Emit test files for all types (skip protocols — they have no data to test)
+  if (emitTarget["test-dir"]) {
+    const importPath = emitTarget["import-path"] || "../src/index";
+    for (const n of nodes) {
+      if (n.isProtocol) continue;
+      const testContext = buildTestContext(n);
+      const testCode = emitTypeScriptTest({
+        ...testContext,
+        importPath,
+        namespace: tsNamespace,
+      });
+      await emitTypeScriptFile(context, `${toKebabCase(n.typeName.name)}.test.ts`, testCode, emitTarget["test-dir"]);
+    }
+  }
+
+  // Emit index.ts file
+  const indexContext = buildIndexContext(nodes);
+  const indexCode = emitTypeScriptIndex(indexContext.baseTypes, indexContext.types);
+  await emitTypeScriptFile(context, "index.ts", indexCode, emitTarget["output-dir"]);
+
+  // Emit eslint.config.js to project root (parent of output-dir)
+  if (emitTarget["output-dir"]) {
+    const projectRoot = resolve(process.cwd(), emitTarget["output-dir"], "..");
+    const eslintConfigCode = emitEslintConfig();
+    await emitTypeScriptFile(context, "eslint.config.js", eslintConfigCode, projectRoot);
+  }
+
+  // Format emitted files if format option is enabled (default: true)
+  if (emitTarget.format !== false) {
+    const outputDir = emitTarget["output-dir"]
+      ? resolve(process.cwd(), emitTarget["output-dir"])
+      : context.emitterOutputDir;
+    const testDir = emitTarget["test-dir"]
+      ? resolve(process.cwd(), emitTarget["test-dir"])
+      : undefined;
+
+    formatTypeScriptFiles(outputDir, testDir);
+  }
+};
+
+/**
+ * Format TypeScript files using prettier.
+ */
+function formatTypeScriptFiles(outputDir: string, testDir?: string): void {
+  const projectRoot = findTypeScriptProjectRoot(outputDir);
+  if (!projectRoot) {
+    console.warn(`Warning: Could not find package.json. Skipping formatting.`);
+    return;
+  }
+
+  const dirs = [outputDir, ...(testDir ? [testDir] : [])];
+
+  for (const dir of dirs) {
+    const globPattern = `${dir}/**/*.ts`;
+    // Run prettier — use execFileSync to avoid shell injection from paths
+    try {
+      execFileSync("npx", ["prettier", "--write", globPattern], {
+        cwd: projectRoot,
+        stdio: "pipe",
+        encoding: "utf-8",
+      });
+    } catch (error) {
+      console.warn(`Warning: prettier formatting failed for ${dir}. You may need to install prettier.`);
+    }
+
+    // Run eslint fix
+    try {
+      execFileSync("npx", ["eslint", "--fix", globPattern], {
+        cwd: projectRoot,
+        stdio: "pipe",
+        encoding: "utf-8",
+      });
+    } catch (error) {
+      // ESLint errors are common, don't warn about them
+    }
+  }
+}
+
+/**
+ * Find the TypeScript project root by looking for package.json.
+ */
+function findTypeScriptProjectRoot(startDir: string): string | undefined {
+  let currentDir = resolve(startDir);
+  const root = resolve("/");
+
+  while (currentDir !== root && currentDir !== dirname(currentDir)) {
+    const packageJsonPath = resolve(currentDir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      return currentDir;
+    }
+    currentDir = dirname(currentDir);
+  }
+
+  return undefined;
+}
+
+/**
+ * Build context for rendering the index.ts file.
+ */
+function buildIndexContext(nodes: TypeNode[]): { baseTypes: TypeNode[]; types: TypeNode[] } {
+  return {
+    baseTypes: nodes.filter((n) => !n.base),
+    types: nodes,
+  };
+}
+
+/**
+ * Build context for rendering a test file.
+ */
+function buildTestContext(node: TypeNode): BaseTestContext {
+  return buildBaseTestContext(node, undefined, typescriptTestOptions);
+}
+
+/**
+ * Write generated TypeScript content to file.
+ */
+async function emitTypeScriptFile(
+  context: EmitContext<PromptyEmitterOptions>,
+  filename: string,
+  content: string,
+  outputDir?: string
+): Promise<void> {
+  outputDir = outputDir || `${context.emitterOutputDir}/typescript`;
+  const filePath = resolvePath(outputDir, filename);
+
+  await emitFile(context.program, {
+    path: filePath,
+    content,
+  });
+}
diff --git a/schema/emitter/src/languages/typescript/emitter.ts b/schema/emitter/src/languages/typescript/emitter.ts
new file mode 100644
index 00000000..bcfeca3f
--- /dev/null
+++ b/schema/emitter/src/languages/typescript/emitter.ts
@@ -0,0 +1,976 @@
+/**
+ * TypeScript code emitter — Declaration IR → TypeScript source code.
+ *
+ * Replaces `file.ts.njk` (~414 lines of Nunjucks templates)
+ * with a typed TypeScript function that walks the FileDecl tree.
+ *
+ * The emitter produces correctly-formatted TypeScript code using modern
+ * class patterns with `Partial<T>` constructors. Output is post-processed
+ * by prettier + eslint, so exact whitespace is not critical.
+ *
+ * Structural blocks emitted (in order):
+ *   1. Header comment (auto-generated warning)
+ *   2. Imports (LoadContext/SaveContext, referenced types)
+ *   3. For each type in the file:
+ *      a. [abstract] class definition with extends
+ *      b. shorthandProperty static ClassVar
+ *      c. Field declarations with type annotations + defaults
+ *      d. Constructor with Partial<T>
+ *      e. //#region Load Methods
+ *         - load() static method
+ *         - loadKind() for polymorphic dispatch (private static)
+ *         - Collection helpers (loadX / saveX)
+ *      f. //#endregion
+ *      g. //#region Save Methods
+ *         - save() instance method
+ *         - toYaml() / toJson()
+ *         - fromJson() / fromYaml() static methods
+ *      h. //#endregion
+ *      i. Factory static methods
+ *      j. Method stubs (as comments)
+ */
+
+import {
+  FileDecl,
+  TypeDecl,
+  FieldDecl,
+  LoadAssignment,
+  SaveAssignment,
+  CollectionHelperDecl,
+  PolymorphicDispatchDecl,
+  FactoryDecl,
+  CoercionDecl,
+  PropertyCategory,
+  WireDecl,
+} from "../../ir/declarations.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+import { toKebabCase } from "../../ir/utilities.js";
+
+/**
+ * Type mapping from TypeSpec scalar types to TypeScript types.
+ */
+const TYPE_MAP: Record<string, string> = {
+  string: "string",
+  boolean: "boolean",
+  int32: "number",
+  int64: "number",
+  float32: "number",
+  float64: "number",
+  number: "number",
+  integer: "number",
+  numeric: "number",
+  float: "number",
+  plainDate: "Date",
+  plainTime: "Date",
+  utcDateTime: "Date",
+  bytes: "Uint8Array",
+  url: "string",
+  unknown: "unknown",
+  any: "unknown",
+  dictionary: "Record<string, unknown>",
+};
+
+/**
+ * Map a TypeSpec scalar to its typeof check string for coercion guards.
+ */
+function typeofCheck(scalarType: string): string | null {
+  switch (scalarType) {
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "int32":
+    case "int64":
+    case "float32":
+    case "float64":
+    case "number":
+    case "integer":
+    case "numeric":
+    case "float":
+      return "number";
+    default:
+      return null;
+  }
+}
+
+function paramType(typeStr: string): string {
+  return TYPE_MAP[typeStr] || typeStr;
+}
+
+function returnType(typeStr: string): string {
+  if (typeStr.endsWith("?")) {
+    const inner = typeStr.slice(0, -1);
+    return `${returnType(inner)} | null`;
+  }
+  if (typeStr === "Record<unknown>") return "Record<string, unknown>";
+  return TYPE_MAP[typeStr] || typeStr;
+}
+
+// ============================================================================
+// Main entry point
+// ============================================================================
+
+/**
+ * Emit a complete TypeScript file from a FileDecl.
+ */
+export function emitTypeScriptFile(decl: FileDecl, visitor: ExprVisitor, namespace?: string): string {
+  const lines: string[] = [];
+
+  // 1. Header
+  lines.push("// Copyright (c) Microsoft. All rights reserved.");
+  lines.push("// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.");
+  lines.push("");
+
+  // 2. Imports
+  // Protocol-only files don't need LoadContext/SaveContext
+  const hasNonProtocol = decl.types.some(t => !t.isProtocol);
+  if (hasNonProtocol) {
+    lines.push(`import { LoadContext, SaveContext } from "./context";`);
+  }
+
+  for (const imp of decl.imports) {
+    const kebab = toKebabCase(imp.module);
+    lines.push(`import { ${imp.names.join(", ")} } from "./${kebab}";`);
+  }
+  lines.push("");
+
+  // 3. Emit each type
+  for (const type of decl.types) {
+    emitType(type, lines, visitor);
+    lines.push("");
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+// ============================================================================
+// Type emission
+// ============================================================================
+
+function emitType(type: TypeDecl, lines: string[], visitor: ExprVisitor): void {
+  const name = type.typeName.name;
+
+  // Protocol types → emit as interface with method signatures
+  if (type.isProtocol) {
+    emitProtocolInterface(type, lines);
+    return;
+  }
+
+  // Class definition
+  const abstractPrefix = type.isAbstract ? "abstract " : "";
+  const extendsClause = type.base ? ` extends ${type.base.name}` : "";
+  lines.push(`export ${abstractPrefix}class ${name}${extendsClause} {`);
+
+  // shorthandProperty static
+  const shorthand = type.coercionProperty ? `"${type.coercionProperty}"` : "undefined";
+  lines.push(`  static readonly shorthandProperty: string | undefined = ${shorthand};`);
+  lines.push("");
+
+  // Field declarations
+  for (const field of type.fields) {
+    const annotation = tsTypeAnnotation(field);
+    const defaultVal = tsDefaultValue(field);
+    if (field.isOptional) {
+      lines.push(`  ${field.name}?: ${annotation}${defaultVal};`);
+    } else if (defaultVal === "" && field.category.kind === "complex") {
+      // Required complex types without defaults need definite assignment assertion
+      lines.push(`  ${field.name}!: ${annotation};`);
+    } else {
+      lines.push(`  ${field.name}: ${annotation}${defaultVal};`);
+    }
+  }
+  lines.push("");
+
+  // Constructor
+  emitConstructor(type, lines);
+
+  // //#region Load Methods
+  lines.push("  //#region Load Methods");
+  lines.push("");
+
+  // load() static method
+  emitLoadMethod(type, lines);
+
+  // Polymorphic dispatch
+  if (type.polymorphicDispatch) {
+    emitPolymorphicDispatch(name, type.polymorphicDispatch, lines);
+  }
+
+  // Collection helpers
+  for (const helper of type.collectionHelpers) {
+    emitCollectionLoadHelper(name, helper, lines);
+    emitCollectionSaveHelper(name, helper, lines);
+  }
+
+  lines.push("  //#endregion");
+  lines.push("");
+
+  // //#region Save Methods
+  lines.push("  //#region Save Methods");
+  lines.push("");
+
+  // save() instance method
+  emitSaveMethod(type, lines);
+
+  // toWire() method (only if wire mappings exist)
+  if (type.wire !== null) {
+    emitToWireMethod(type, lines);
+  }
+
+  // toYaml / toJson
+  emitToYaml(name, lines);
+  emitToJson(name, lines);
+
+  // fromJson / fromYaml
+  emitFromJson(name, type, lines);
+  emitFromYaml(name, type, lines);
+
+  lines.push("  //#endregion");
+
+  // Factory methods
+  if (type.factories.length > 0) {
+    lines.push("");
+    for (const factory of type.factories) {
+      emitFactory(name, factory, visitor, lines);
+    }
+  }
+
+  // Method stubs — emitted as a sibling interface below the class
+
+  lines.push("}");
+
+  // Emit MessageHelpers-style interface after the class
+  if (type.methods.length > 0) {
+    emitMethodHelpersInterface(type, lines);
+  }
+}
+
+/**
+ * Emit a TypeScript interface named `<TypeName>Helpers` declaring the
+ * `@method` contract for a concrete type. The generated class does NOT
+ * implement this interface on its own — runtime code must provide an
+ * implementation. The type checker verifies conformance via structural typing.
+ */
+function emitMethodHelpersInterface(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+  lines.push("");
+  lines.push(`/**`);
+  lines.push(` * Helper contract for \`${name}\`.`);
+  lines.push(` *`);
+  lines.push(` * Runtime implementations must provide these methods on every ${name}`);
+  lines.push(` * instance (either on the generated class or on a wrapper type). The`);
+  lines.push(` * TypeScript compiler enforces conformance wherever a value is typed as`);
+  lines.push(` * \`${name}Helpers\`.`);
+  lines.push(` */`);
+  lines.push(`export interface ${name}Helpers {`);
+  for (const m of type.methods) {
+    if (m.description) {
+      lines.push(`  /** ${m.description} */`);
+    }
+    const params = Object.entries(m.params)
+      .map(([pName, pType]) => `${pName}: ${returnType(pType)}`)
+      .join(", ");
+    const ret = returnType(m.returns);
+    // Zero-param non-verb methods are emitted as getter-style readonly
+    // properties (matches C#/Python emitters). Callers access them without
+    // parens, e.g. ``msg.text``.
+    const isGetter = Object.keys(m.params).length === 0 && !isMethodStyle(m.name);
+    if (isGetter) {
+      lines.push(`  readonly ${m.name}: ${ret};`);
+    } else {
+      lines.push(`  ${m.name}(${params}): ${ret};`);
+    }
+  }
+  lines.push("}");
+}
+
+/**
+ * Verbs that indicate an action — zero-param @methods whose name starts with
+ * one of these are emitted as regular TypeScript methods. Everything else
+ * becomes a ``readonly`` getter-style property. Mirrors the C#/Python emitter
+ * heuristic so that ``message.text`` stays a property and
+ * ``message.toTextContent()`` stays a method in every runtime.
+ */
+const TS_METHOD_VERB_PREFIXES = [
+  "to", "get", "set", "fetch", "compute", "make", "build", "create",
+  "load", "save", "convert", "parse", "format", "render", "serialize",
+  "deserialize", "find", "calculate", "invoke", "execute", "run",
+];
+
+function isMethodStyle(name: string): boolean {
+  const lower = name.toLowerCase();
+  for (const prefix of TS_METHOD_VERB_PREFIXES) {
+    if (lower === prefix) return true;
+    if (lower.startsWith(prefix) && name.length > prefix.length) {
+      const next = name[prefix.length];
+      if (next === next.toUpperCase() && next !== next.toLowerCase()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// ============================================================================
+// Protocol interface emission
+// ============================================================================
+
+/**
+ * Emit a TypeScript interface for a protocol type.
+ * Protocols have methods but no data fields, load/save, or serialization.
+ */
+function emitProtocolInterface(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+
+  if (type.description) {
+    lines.push(`/** ${type.description} */`);
+  }
+  lines.push(`export interface ${name} {`);
+
+  for (const method of type.methods) {
+    if (method.description) {
+      lines.push(`  /** ${method.description} */`);
+    }
+    const params = Object.entries(method.params)
+      .map(([pName, pType]) => `${pName}: ${returnType(pType)}`)
+      .join(", ");
+    const ret = returnType(method.returns);
+    const optMark = method.optional ? "?" : "";
+
+    if (method.sync) {
+      lines.push(`  ${method.name}${optMark}(${params}): ${ret};`);
+    } else {
+      lines.push(`  ${method.name}${optMark}(${params}): Promise<${ret}>;`);
+    }
+  }
+
+  lines.push("}");
+}
+
+function tsTypeAnnotation(f: FieldDecl): string {
+  const cat = f.category;
+  switch (cat.kind) {
+    case "dict":
+      return f.isOptional ? "Record<string, unknown> | undefined" : "Record<string, unknown>";
+    case "collection_scalar":
+      return `${TYPE_MAP[cat.scalarType] || "unknown"}[]`;
+    case "collection_complex":
+      return `${cat.typeName}[]`;
+    case "scalar": {
+      const tsType = TYPE_MAP[cat.scalarType] || "unknown";
+      return f.isOptional ? `${tsType} | undefined` : tsType;
+    }
+    case "complex":
+      return f.isOptional ? `${cat.typeName} | undefined` : cat.typeName;
+  }
+}
+
+// ============================================================================
+// Default values
+// ============================================================================
+
+function tsDefaultValue(f: FieldDecl): string {
+  const cat = f.category;
+
+  if (cat.kind === "collection_scalar" || cat.kind === "collection_complex") {
+    return " = []";
+  }
+
+  if (f.isOptional) {
+    return "";
+  }
+
+  if (cat.kind === "dict") {
+    return " = {}";
+  }
+
+  if (cat.kind === "scalar") {
+    return tsScalarDefault(cat.scalarType, f.defaultValue);
+  }
+
+  // complex required types — no inline default, handled by constructor
+  return "";
+}
+
+function tsScalarDefault(scalarType: string, defaultValue: string | number | boolean | null): string {
+  if (defaultValue !== undefined && defaultValue !== null) {
+    if (typeof defaultValue === "string") {
+      return ` = "${defaultValue}"`;
+    }
+    return ` = ${defaultValue}`;
+  }
+
+  switch (scalarType) {
+    case "string":
+      return ' = ""';
+    case "boolean":
+      return " = false";
+    case "number":
+    case "int32":
+    case "int64":
+    case "float32":
+    case "float64":
+    case "integer":
+    case "numeric":
+    case "float":
+      return " = 0";
+    default:
+      return "";
+  }
+}
+
+// ============================================================================
+// Constructor
+// ============================================================================
+
+function emitConstructor(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+  const hasBase = type.base !== null;
+
+  lines.push(`  constructor(init?: Partial<${name}>) {`);
+  if (hasBase) {
+    lines.push("    super(init);");
+  }
+
+  for (const field of type.fields) {
+    const cat = field.category;
+    if (field.isOptional) {
+      lines.push(`    if (init?.${field.name} !== undefined) {`);
+      lines.push(`      this.${field.name} = init.${field.name};`);
+      lines.push("    }");
+    } else if (cat.kind === "collection_scalar" || cat.kind === "collection_complex") {
+      lines.push(`    this.${field.name} = init?.${field.name} ?? [];`);
+    } else if (cat.kind === "dict") {
+      lines.push(`    this.${field.name} = init?.${field.name} ?? {};`);
+    } else if (cat.kind === "scalar") {
+      const def = tsConstructorDefault(cat.scalarType, field.defaultValue);
+      lines.push(`    this.${field.name} = init?.${field.name} ?? ${def};`);
+    } else {
+      // complex required — use init value or construct a new default
+      lines.push(`    if (init?.${field.name} !== undefined) {`);
+      lines.push(`      this.${field.name} = init.${field.name};`);
+      lines.push("    }");
+    }
+  }
+
+  lines.push("  }");
+  lines.push("");
+}
+
+function tsConstructorDefault(scalarType: string, defaultValue: string | number | boolean | null): string {
+  if (defaultValue !== undefined && defaultValue !== null) {
+    if (typeof defaultValue === "string") {
+      return `"${defaultValue}"`;
+    }
+    return String(defaultValue);
+  }
+
+  switch (scalarType) {
+    case "string":
+      return '""';
+    case "boolean":
+      return "false";
+    case "number":
+    case "int32":
+    case "int64":
+    case "float32":
+    case "float64":
+    case "integer":
+    case "numeric":
+    case "float":
+      return "0";
+    default:
+      return '""';
+  }
+}
+
+// ============================================================================
+// load() method
+// ============================================================================
+
+function emitLoadMethod(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+
+  lines.push(`  static load(data: Record<string, unknown>, context?: LoadContext): ${name} {`);
+
+  // Context pre-processing
+  lines.push("    if (context) {");
+  lines.push("      data = context.processInput(data) as Record<string, unknown>;");
+  lines.push("    }");
+
+  // Coercion checks — group by JS typeof to handle int/float distinction
+  if (type.load.coercions.length > 0) {
+    lines.push("");
+    lines.push("    // Handle alternate representations");
+    emitCoercionBranches(name, type.load.coercions, type, lines);
+  }
+
+  lines.push("");
+
+  // Create instance (polymorphic dispatch or direct)
+  if (type.load.hasPolymorphicDispatch && type.polymorphicDispatch) {
+    lines.push(`    // Load polymorphic ${name} instance`);
+    lines.push(`    const instance = ${name}.loadKind(data, context);`);
+  } else {
+    lines.push(`    const instance = new ${name}();`);
+  }
+
+  lines.push("");
+
+  // Per-property assignments
+  for (const a of type.load.assignments) {
+    lines.push(`    if (data["${a.sourceName}"] !== undefined && data["${a.sourceName}"] !== null) {`);
+    lines.push(`      ${emitLoadAssignment(a)}`);
+    lines.push("    }");
+  }
+
+  // Context post-processing
+  lines.push("");
+  lines.push("    if (context) {");
+  lines.push(`      return context.processOutput(instance) as ${name};`);
+  lines.push("    }");
+  lines.push("    return instance;");
+  lines.push("  }");
+  lines.push("");
+}
+
+function emitLoadAssignment(a: LoadAssignment): string {
+  const cat = a.category;
+  switch (cat.kind) {
+    case "scalar": {
+      const tsType = TYPE_MAP[cat.scalarType];
+      switch (tsType) {
+        case "string":
+          return `instance.${a.fieldName} = String(data["${a.sourceName}"]);`;
+        case "number":
+          return `instance.${a.fieldName} = Number(data["${a.sourceName}"]);`;
+        case "boolean":
+          return `instance.${a.fieldName} = Boolean(data["${a.sourceName}"]);`;
+        default:
+          return `instance.${a.fieldName} = data["${a.sourceName}"] as ${tsType};`;
+      }
+    }
+    case "complex":
+      return `instance.${a.fieldName} = ${cat.typeName}.load(data["${a.sourceName}"] as Record<string, unknown>, context);`;
+    case "collection_scalar": {
+      const tsType = TYPE_MAP[cat.scalarType];
+      switch (tsType) {
+        case "string":
+          return `instance.${a.fieldName} = (data["${a.sourceName}"] as unknown[]).map(v => String(v));`;
+        case "number":
+          return `instance.${a.fieldName} = (data["${a.sourceName}"] as unknown[]).map(v => Number(v));`;
+        case "boolean":
+          return `instance.${a.fieldName} = (data["${a.sourceName}"] as unknown[]).map(v => Boolean(v));`;
+        default:
+          return `instance.${a.fieldName} = data["${a.sourceName}"] as ${tsType}[];`;
+      }
+    }
+    case "collection_complex":
+      return `instance.${a.fieldName} = ${a.parentTypeName}.load${capitalize(a.fieldName)}(data["${a.sourceName}"] as unknown[], context);`;
+    case "dict":
+      return `instance.${a.fieldName} = data["${a.sourceName}"] as Record<string, unknown>;`;
+  }
+}
+
+/**
+ * Emit coercion branches, grouping coercions that share the same JS typeof.
+ *
+ * In TypeScript, int32 and float64 both map to `typeof data === "number"`.
+ * When multiple coercions share a typeof, we emit a single outer `if` with
+ * `Number.isInteger()` sub-branches to disambiguate.
+ */
+function emitCoercionBranches(
+  typeName: string,
+  coercions: CoercionDecl[],
+  type: TypeDecl,
+  lines: string[],
+): void {
+  // Group coercions by JS typeof check
+  const groups = new Map<string, CoercionDecl[]>();
+  for (const c of coercions) {
+    const jsType = typeofCheck(c.scalarType);
+    if (!jsType) continue;
+    if (!groups.has(jsType)) groups.set(jsType, []);
+    groups.get(jsType)!.push(c);
+  }
+
+  for (const [jsType, group] of groups) {
+    if (group.length === 1) {
+      // Single coercion for this typeof — emit simple branch
+      emitCoercionBranch(typeName, group[0], type, lines);
+    } else {
+      // Multiple coercions sharing the same typeof (e.g., int32 + float64 → "number")
+      lines.push(`    if (typeof data === "${jsType}") {`);
+
+      // Find integer and float coercions
+      const intCoercion = group.find(c => isIntegerScalar(c.scalarType));
+      const floatCoercion = group.find(c => !isIntegerScalar(c.scalarType));
+
+      if (intCoercion && floatCoercion) {
+        // Use Number.isInteger to disambiguate
+        lines.push("      if (Number.isInteger(data)) {");
+        emitCoercionBody(typeName, intCoercion, type, lines, "        ");
+        lines.push("      } else {");
+        emitCoercionBody(typeName, floatCoercion, type, lines, "        ");
+        lines.push("      }");
+      } else {
+        // Fallback: just emit them sequentially (shouldn't happen)
+        for (const c of group) {
+          emitCoercionBody(typeName, c, type, lines, "      ");
+        }
+      }
+
+      lines.push("    }");
+    }
+  }
+}
+
+function isIntegerScalar(scalarType: string): boolean {
+  return scalarType === "int32" || scalarType === "int64" || scalarType === "integer";
+}
+
+/**
+ * Emit a single coercion branch — typeof check with early return.
+ */
+function emitCoercionBranch(
+  typeName: string,
+  c: CoercionDecl,
+  type: TypeDecl,
+  lines: string[],
+): void {
+  const jsType = typeofCheck(c.scalarType);
+  if (!jsType) return;
+
+  lines.push(`    if (typeof data === "${jsType}") {`);
+  emitCoercionBody(typeName, c, type, lines, "      ");
+  lines.push("    }");
+}
+
+/**
+ * Emit the body of a coercion branch (instance creation + property assignment).
+ */
+function emitCoercionBody(
+  typeName: string,
+  c: CoercionDecl,
+  type: TypeDecl,
+  lines: string[],
+  indent: string,
+): void {
+  if (c.needsDispatch && type.polymorphicDispatch) {
+    // Dynamic discriminator — must go through dispatch
+    const dictFields = c.assignments.map(a => {
+      const val = a.isInput ? "data" : `"${a.literalValue}"`;
+      return `"${a.fieldName}": ${val}`;
+    });
+    lines.push(`${indent}return ${typeName}.loadKind({ ${dictFields.join(", ")} } as Record<string, unknown>, context);`);
+  } else {
+    // Direct property setting
+    lines.push(`${indent}const instance = new ${typeName}();`);
+    for (const a of c.assignments) {
+      if (a.isInput) {
+        lines.push(`${indent}instance.${a.fieldName} = data as ${TYPE_MAP[c.scalarType] || "unknown"};`);
+      } else {
+        lines.push(`${indent}instance.${a.fieldName} = "${a.literalValue}";`);
+      }
+    }
+    lines.push(`${indent}if (context) {`);
+    lines.push(`${indent}  return context.processOutput(instance) as ${typeName};`);
+    lines.push(`${indent}}`);
+    lines.push(`${indent}return instance;`);
+  }
+}
+
+// ============================================================================
+// Polymorphic dispatch (loadKind)
+// ============================================================================
+
+function emitPolymorphicDispatch(
+  parentName: string,
+  dispatch: PolymorphicDispatchDecl,
+  lines: string[],
+): void {
+  lines.push(`  private static loadKind(data: Record<string, unknown>, context?: LoadContext): ${parentName} {`);
+  lines.push(`    const discriminatorValue = data["${dispatch.discriminatorField}"];`);
+  lines.push("    if (discriminatorValue !== undefined && discriminatorValue !== null) {");
+  lines.push("      const discriminator = String(discriminatorValue).toLowerCase();");
+  lines.push("      switch (discriminator) {");
+
+  for (const v of dispatch.variants) {
+    lines.push(`        case "${v.value}":`);
+    lines.push(`          return ${v.typeName.name}.load(data, context);`);
+  }
+
+  // Default handling
+  if (dispatch.defaultVariant) {
+    lines.push("        default:");
+    if (dispatch.defaultVariant.isSelfReference) {
+      lines.push(`          return new ${parentName}();`);
+    } else {
+      lines.push(`          return ${dispatch.defaultVariant.typeName.name}.load(data, context);`);
+    }
+  } else {
+    lines.push("        default:");
+    lines.push(`          throw new Error(\`Unknown ${parentName} discriminator value: \${discriminator}\`);`);
+  }
+
+  lines.push("      }");
+  lines.push("    }");
+
+  // Missing discriminator
+  if (dispatch.isAbstract) {
+    lines.push(`    throw new Error("Missing ${parentName} discriminator property: '${dispatch.discriminatorField}'");`);
+  } else {
+    lines.push(`    return new ${parentName}();`);
+  }
+
+  lines.push("  }");
+  lines.push("");
+}
+
+// ============================================================================
+// Collection helpers (loadX / saveX)
+// ============================================================================
+
+function emitCollectionLoadHelper(parentName: string, helper: CollectionHelperDecl, lines: string[]): void {
+  const methodName = `load${capitalize(helper.propertyName)}`;
+  const elemName = helper.elementTypeName.name;
+  const firstInnerField = helper.innerFields[0] || "kind";
+
+  lines.push(`  static ${methodName}(data: Record<string, unknown>[] | unknown[], context?: LoadContext): ${elemName}[] {`);
+  lines.push("    if (!Array.isArray(data)) {");
+  lines.push("      // Convert dict/object format to array format");
+  lines.push("      const result: Record<string, unknown>[] = [];");
+  lines.push("      for (const [k, v] of Object.entries(data)) {");
+  lines.push("        if (typeof v === \"object\" && v !== null && !Array.isArray(v)) {");
+  lines.push(`          result.push({ name: k, ...(v as Record<string, unknown>) });`);
+  lines.push("        } else {");
+  lines.push(`          result.push({ name: k, "${firstInnerField}": v });`);
+  lines.push("        }");
+  lines.push("      }");
+  lines.push("      data = result;");
+  lines.push("    }");
+  lines.push(`    return data.map(item => ${elemName}.load(item as Record<string, unknown>, context));`);
+  lines.push("  }");
+  lines.push("");
+}
+
+function emitCollectionSaveHelper(parentName: string, helper: CollectionHelperDecl, lines: string[]): void {
+  const loadMethodName = `save${capitalize(helper.propertyName)}`;
+  const elemName = helper.elementTypeName.name;
+
+  lines.push(`  static ${loadMethodName}(items: ${elemName}[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {`);
+  lines.push("    if (!context) {");
+  lines.push("      context = new SaveContext();");
+  lines.push("    }");
+
+  if (helper.hasNameProperty) {
+    lines.push("");
+    lines.push('    if (context.collectionFormat === "array") {');
+    lines.push("      return items.map(item => item.save(context));");
+    lines.push("    }");
+    lines.push("");
+    lines.push("    // Object format: use name as key");
+    lines.push("    const result: Record<string, unknown> = {};");
+    lines.push("    for (const item of items) {");
+    lines.push("      const itemData = item.save(context) as Record<string, unknown>;");
+    lines.push('      const name = itemData["name"] as string | undefined;');
+    lines.push('      delete itemData["name"];');
+    lines.push("      if (name) {");
+    lines.push("        // Check if we can use shorthand (only primary property set)");
+    lines.push(`        const shorthand = (item.constructor as typeof ${elemName}).shorthandProperty;`);
+    lines.push("        if (context.useShorthand && shorthand && Object.keys(itemData).length === 1 && shorthand in itemData) {");
+    lines.push("          result[name] = itemData[shorthand];");
+    lines.push("          continue;");
+    lines.push("        }");
+    lines.push("        result[name] = itemData;");
+    lines.push("      } else {");
+    lines.push("        // No name, fall back to array format for this item");
+    lines.push('        if (!result["_unnamed"]) {');
+    lines.push('          result["_unnamed"] = [];');
+    lines.push("        }");
+    lines.push('        (result["_unnamed"] as unknown[]).push(itemData);');
+    lines.push("      }");
+    lines.push("    }");
+    lines.push("    return result;");
+  } else {
+    lines.push("");
+    lines.push("    // This type doesn't have a 'name' property, so always use array format");
+    lines.push("    return items.map(item => item.save(context));");
+  }
+
+  lines.push("  }");
+  lines.push("");
+}
+
+// ============================================================================
+// save() method
+// ============================================================================
+
+function emitSaveMethod(type: TypeDecl, lines: string[]): void {
+  const name = type.typeName.name;
+
+  lines.push("  save(context?: SaveContext): Record<string, unknown> {");
+  lines.push("    let obj: this = this;");
+  lines.push("    if (context) {");
+  lines.push(`      obj = context.processObject(obj) as this;`);
+  lines.push("    }");
+  lines.push("");
+
+  if (type.save.hasBase) {
+    lines.push("    // Start with parent class properties");
+    lines.push("    const result = super.save(context);");
+  } else {
+    lines.push("    const result: Record<string, unknown> = {};");
+  }
+
+  lines.push("");
+
+  // Per-property save assignments
+  for (const a of type.save.assignments) {
+    if (a.isOptional) {
+      lines.push(`    if (obj.${a.fieldName} !== undefined && obj.${a.fieldName} !== null) {`);
+      lines.push(`      ${emitSaveAssignment(a)}`);
+      lines.push("    }");
+    } else {
+      lines.push(`    if (obj.${a.fieldName} !== undefined && obj.${a.fieldName} !== null) {`);
+      lines.push(`      ${emitSaveAssignment(a)}`);
+      lines.push("    }");
+    }
+  }
+
+  // Context post-processing (only for root types without base)
+  if (!type.save.hasBase) {
+    lines.push("");
+    lines.push("    if (context) {");
+    lines.push("      return context.processDict(result);");
+    lines.push("    }");
+  }
+
+  lines.push("    return result;");
+  lines.push("  }");
+  lines.push("");
+}
+
+function emitSaveAssignment(a: SaveAssignment): string {
+  const cat = a.category;
+  switch (cat.kind) {
+    case "scalar":
+    case "dict":
+    case "collection_scalar":
+      return `result["${a.targetName}"] = obj.${a.fieldName};`;
+    case "collection_complex":
+      return `result["${a.targetName}"] = ${a.parentTypeName}.save${capitalize(a.fieldName)}(obj.${a.fieldName}, context);`;
+    case "complex":
+      return `result["${a.targetName}"] = obj.${a.fieldName}.save(context);`;
+  }
+}
+
+// ============================================================================
+// toWire() method
+// ============================================================================
+
+function emitToWireMethod(type: TypeDecl, lines: string[]): void {
+  const wire = type.wire!;
+
+  lines.push("  toWire(provider: string): Record<string, unknown> {");
+  lines.push("    const data = this.save();");
+  lines.push("    const result: Record<string, unknown> = {};");
+  lines.push("    const wireMap: Record<string, Record<string, string>> = {");
+
+  for (const mapping of wire.mappings) {
+    const entries = Object.entries(mapping.wireNames)
+      .map(([prov, wireName]) => `"${prov}": "${wireName}"`)
+      .join(", ");
+    lines.push(`      "${mapping.fieldName}": { ${entries} },`);
+  }
+
+  lines.push("    };");
+  lines.push("    for (const [key, value] of Object.entries(data)) {");
+  lines.push("      const mapping = wireMap[key];");
+  lines.push("      if (mapping?.[provider]) {");
+  lines.push("        result[mapping[provider]] = value;");
+  lines.push("      }");
+  lines.push("    }");
+  lines.push("    return result;");
+  lines.push("  }");
+  lines.push("");
+}
+
+// ============================================================================
+// toYaml() / toJson()
+// ============================================================================
+
+function emitToYaml(name: string, lines: string[]): void {
+  lines.push("  toYaml(context?: SaveContext): string {");
+  lines.push("    context = context ?? new SaveContext();");
+  lines.push("    return context.toYaml(this.save(context));");
+  lines.push("  }");
+  lines.push("");
+}
+
+function emitToJson(name: string, lines: string[]): void {
+  lines.push("  toJson(context?: SaveContext, indent: number = 2): string {");
+  lines.push("    context = context ?? new SaveContext();");
+  lines.push("    return context.toJson(this.save(context), indent);");
+  lines.push("  }");
+  lines.push("");
+}
+
+// ============================================================================
+// fromJson() / fromYaml()
+// ============================================================================
+
+function emitFromJson(name: string, type: TypeDecl, lines: string[]): void {
+  lines.push(`  static fromJson(json: string, context?: LoadContext): ${name} {`);
+  lines.push("    const data = JSON.parse(json);");
+
+  if (type.load.coercions.length > 0) {
+    // Pass raw parsed value directly to load() — it handles typeof coercions
+    lines.push(`    return ${name}.load(data as Record<string, unknown>, context);`);
+  } else {
+    lines.push(`    return ${name}.load(data as Record<string, unknown>, context);`);
+  }
+
+  lines.push("  }");
+  lines.push("");
+}
+
+function emitFromYaml(name: string, type: TypeDecl, lines: string[]): void {
+  lines.push(`  static fromYaml(yaml: string, context?: LoadContext): ${name} {`);
+  lines.push('    const { parse } = require("yaml");');
+  lines.push("    const data = parse(yaml);");
+
+  if (type.load.coercions.length > 0) {
+    // Pass raw parsed value directly to load() — it handles typeof coercions
+    lines.push(`    return ${name}.load(data as Record<string, unknown>, context);`);
+  } else {
+    lines.push(`    return ${name}.load(data as Record<string, unknown>, context);`);
+  }
+
+  lines.push("  }");
+  lines.push("");
+}
+
+// ============================================================================
+// Factory methods
+// ============================================================================
+
+function emitFactory(parentName: string, factory: FactoryDecl, visitor: ExprVisitor, lines: string[]): void {
+  const params = Object.entries(factory.params)
+    .map(([pName, pType]) => `${pName}: ${paramType(pType)}`)
+    .join(", ");
+
+  lines.push(`  static ${factory.name}(${params}): ${parentName} {`);
+  lines.push(`    return ${visitor.visitExpr(factory.body)};`);
+  lines.push("  }");
+  lines.push("");
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/** Capitalize first letter (camelCase → PascalCase for method names). */
+function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
diff --git a/schema/emitter/src/templates/typescript/context.ts.njk b/schema/emitter/src/languages/typescript/scaffolding.ts
similarity index 50%
rename from schema/emitter/src/templates/typescript/context.ts.njk
rename to schema/emitter/src/languages/typescript/scaffolding.ts
index 5aa7f01a..abde8eea 100644
--- a/schema/emitter/src/templates/typescript/context.ts.njk
+++ b/schema/emitter/src/languages/typescript/scaffolding.ts
@@ -1,5 +1,27 @@
-{# Template for generating TypeScript LoadContext and SaveContext classes #}
-// Copyright (c) Microsoft. All rights reserved.
+/**
+ * TypeScript scaffolding emitter — static/structural files.
+ *
+ * Replaces the Nunjucks templates:
+ *   - `context.ts.njk`       → emitTypeScriptContext()
+ *   - `index.ts.njk`         → emitTypeScriptIndex()
+ *   - `eslint.config.js.njk` → emitEslintConfig()
+ *
+ * These emit files whose content depends only on the type graph
+ * shape (not on the Declaration IR used for per-type files).
+ */
+
+import { TypeNode } from "../../ir/ast.js";
+import { toKebabCase } from "../../ir/utilities.js";
+
+// ============================================================================
+// Context classes (LoadContext, SaveContext)
+// ============================================================================
+
+/**
+ * Emit static TypeScript context classes (LoadContext, SaveContext).
+ */
+export function emitTypeScriptContext(): string {
+  return `// Copyright (c) Microsoft. All rights reserved.
 // WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
 
 import * as yaml from "yaml";
@@ -142,3 +164,91 @@ export class SaveContext {
     return JSON.stringify(data, null, indent);
   }
 }
+`;
+}
+
+// ============================================================================
+// Barrel export index.ts
+// ============================================================================
+
+/**
+ * Emit the barrel export index.ts file.
+ */
+export function emitTypeScriptIndex(baseTypes: TypeNode[], _types: TypeNode[]): string {
+  const lines: string[] = [];
+  lines.push("// Copyright (c) Microsoft. All rights reserved.");
+  lines.push("// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.");
+  lines.push("");
+  lines.push('export { LoadContext, SaveContext } from "./context";');
+
+  for (const type of baseTypes) {
+    // Protocol types are interfaces (type-only) — use `export type` for isolatedModules compat
+    const exportKeyword = type.isProtocol ? "export type" : "export";
+    if (type.childTypes.length > 0) {
+      const exports = [type.typeName.name, ...type.childTypes.map((c) => c.typeName.name)];
+      lines.push("");
+      lines.push(`${exportKeyword} {`);
+      for (const name of exports) {
+        lines.push(`  ${name},`);
+      }
+      lines.push(`} from "./${toKebabCase(type.typeName.name)}";`);
+    } else {
+      lines.push(`${exportKeyword} { ${type.typeName.name} } from "./${toKebabCase(type.typeName.name)}";`);
+    }
+  }
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// ============================================================================
+// ESLint configuration
+// ============================================================================
+
+/**
+ * Emit the static ESLint configuration file.
+ */
+export function emitEslintConfig(): string {
+  return `// ESLint configuration for auto-generated AgentSchema TypeScript code
+// This file is auto-generated by the AgentSchema emitter
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    files: ["src/**/*.ts"],
+    rules: {
+      // Allow unused vars prefixed with underscore
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
+      ],
+      // Allow explicit any in generated code
+      "@typescript-eslint/no-explicit-any": "off",
+      // Allow non-null assertions in generated code
+      "@typescript-eslint/no-non-null-assertion": "off",
+      // Allow require() for dynamic YAML imports in generated code
+      "@typescript-eslint/no-require-imports": "off",
+      // Allow empty blocks in generated shorthand parsing patterns
+      "no-empty": "off",
+    },
+  },
+  {
+    files: ["tests/**/*.ts"],
+    rules: {
+      // Allow explicit any in test code
+      "@typescript-eslint/no-explicit-any": "off",
+      // Allow unused vars in generated tests
+      "@typescript-eslint/no-unused-vars": "off",
+      // Allow require() for dynamic YAML imports
+      "@typescript-eslint/no-require-imports": "off",
+    },
+  },
+  {
+    ignores: ["dist/**", "node_modules/**", "*.config.*"],
+  }
+);
+`;
+}
diff --git a/schema/emitter/src/languages/typescript/test-emitter.ts b/schema/emitter/src/languages/typescript/test-emitter.ts
new file mode 100644
index 00000000..a505a10a
--- /dev/null
+++ b/schema/emitter/src/languages/typescript/test-emitter.ts
@@ -0,0 +1,214 @@
+/**
+ * TypeScript test file emitter — BaseTestContext → vitest source code.
+ *
+ * Replaces the Nunjucks templates:
+ *   - `test.ts.njk`   → emitTypeScriptTest()
+ *   - `_macros.njk`    → factoryParamTestValue() (test-specific macro)
+ *
+ * The emitter produces vitest `describe`/`it` blocks for:
+ *   - Construction (default + partial)
+ *   - JSON serialization (load + round-trip per example)
+ *   - YAML serialization (load + round-trip per example)
+ *   - Alternate representations (scalar coercions)
+ *   - Factory methods
+ *   - Load/save (dictionary round-trip)
+ */
+
+import { BaseTestContext } from "../../ir/ast.js";
+
+// ============================================================================
+// Macro replacements
+// ============================================================================
+
+/**
+ * Map a factory parameter type string to a TypeScript test value literal.
+ * Replaces the `factoryParamTestValue` macro from `_macros.njk`.
+ */
+function factoryParamTestValue(typeStr: string): string {
+  switch (typeStr) {
+    case "string":
+      return '"test"';
+    case "boolean":
+      return "true";
+    case "integer":
+    case "int32":
+    case "int64":
+      return "42";
+    case "float":
+    case "float64":
+    case "float32":
+      return "3.14";
+    case "unknown":
+    default:
+      return '"test"';
+  }
+}
+
+/**
+ * Render name in PascalCase (used by coercion test validation keys).
+ */
+function renderName(name: string): string {
+  const pascal = name.replace(/_([a-z])/g, (_, letter: string) => letter.toUpperCase());
+  return pascal.charAt(0).toUpperCase() + pascal.slice(1);
+}
+
+// ============================================================================
+// Main entry point
+// ============================================================================
+
+/**
+ * Emit a vitest test file for a TypeNode.
+ */
+export function emitTypeScriptTest(ctx: BaseTestContext & { importPath: string; namespace: string }): string {
+  const { node, isAbstract, examples, coercions, factories, importPath } = ctx;
+  const typeName = node.typeName.name;
+
+  const lines: string[] = [];
+  lines.push("// Copyright (c) Microsoft. All rights reserved.");
+  lines.push("// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.");
+  lines.push("");
+  lines.push(`import { ${typeName} } from "${importPath}";`);
+  lines.push("");
+  lines.push(`describe("${typeName}", () => {`);
+  lines.push(`  describe("construction", () => {`);
+  lines.push(`    it("should create a new instance with defaults", () => {`);
+  lines.push(`      const instance = new ${typeName}();`);
+  lines.push(`      expect(instance).toBeDefined();`);
+  lines.push(`    });`);
+  lines.push("");
+  lines.push(`    it("should create a new instance with partial initialization", () => {`);
+  lines.push(`      const instance = new ${typeName}({});`);
+  lines.push(`      expect(instance).toBeDefined();`);
+  lines.push(`    });`);
+  lines.push(`  });`);
+
+  // JSON serialization
+  if (examples.length > 0) {
+    lines.push("");
+    lines.push(`  describe("JSON serialization", () => {`);
+    for (let i = 0; i < examples.length; i++) {
+      const example = examples[i];
+      const exampleNum = i + 1;
+      lines.push(`    it("should load from JSON - example ${exampleNum}", () => {`);
+      lines.push("      const json = `" + example.json.join("\\n") + "`;");
+      lines.push(`      const instance = ${typeName}.fromJson(json);`);
+      lines.push(`      expect(instance).toBeDefined();`);
+      for (const val of example.validations) {
+        lines.push(`      expect(instance.${val.key}).toEqual(${val.delimiter}${val.value}${val.delimiter});`);
+      }
+      lines.push(`    });`);
+      lines.push("");
+      lines.push(`    it("should round-trip JSON - example ${exampleNum}", () => {`);
+      lines.push("      const json = `" + example.json.join("\\n") + "`;");
+      lines.push(`      const instance = ${typeName}.fromJson(json);`);
+      lines.push(`      const output = instance.toJson();`);
+      lines.push(`      const reloaded = ${typeName}.fromJson(output);`);
+      for (const val of example.validations) {
+        lines.push(`      expect(reloaded.${val.key}).toEqual(instance.${val.key});`);
+      }
+      lines.push(`    });`);
+    }
+    lines.push(`  });`);
+
+    // YAML serialization
+    lines.push("");
+    lines.push(`  describe("YAML serialization", () => {`);
+    for (let i = 0; i < examples.length; i++) {
+      const example = examples[i];
+      const exampleNum = i + 1;
+      lines.push(`    it("should load from YAML - example ${exampleNum}", () => {`);
+      lines.push("      const yaml = `" + example.yaml.join("\\n") + "`;");
+      lines.push(`      const instance = ${typeName}.fromYaml(yaml);`);
+      lines.push(`      expect(instance).toBeDefined();`);
+      for (const val of example.validations) {
+        lines.push(`      expect(instance.${val.key}).toEqual(${val.delimiter}${val.value}${val.delimiter});`);
+      }
+      lines.push(`    });`);
+      lines.push("");
+      lines.push(`    it("should round-trip YAML - example ${exampleNum}", () => {`);
+      lines.push("      const yaml = `" + example.yaml.join("\\n") + "`;");
+      lines.push(`      const instance = ${typeName}.fromYaml(yaml);`);
+      lines.push(`      const output = instance.toYaml();`);
+      lines.push(`      const reloaded = ${typeName}.fromYaml(output);`);
+      for (const val of example.validations) {
+        lines.push(`      expect(reloaded.${val.key}).toEqual(instance.${val.key});`);
+      }
+      lines.push(`    });`);
+    }
+    lines.push(`  });`);
+  }
+
+  // Alternate representations (coercions)
+  if (coercions.length > 0) {
+    lines.push("");
+    lines.push(`  describe("alternate representations", () => {`);
+    for (const alt of coercions) {
+      lines.push(`    it("should handle ${alt.title} alternate representation", () => {`);
+      lines.push(`      const value = ${alt.value};`);
+      lines.push(`      const json = JSON.stringify(value);`);
+      lines.push(`      const instance = ${typeName}.fromJson(json);`);
+      lines.push(`      expect(instance).toBeDefined();`);
+      for (const val of alt.validations) {
+        const coercionKey = renderName(val.key).toLowerCase().replace(/\./g, "");
+        lines.push(`      expect(instance.${coercionKey}).toEqual(${val.delimiter}${val.value}${val.delimiter});`);
+      }
+      lines.push(`    });`);
+    }
+    lines.push(`  });`);
+  }
+
+  // Factory methods
+  if (factories.length > 0) {
+    lines.push("");
+    lines.push(`  describe("factory methods", () => {`);
+    for (const factory of factories) {
+      const paramValues = Object.values(factory.params)
+        .map((pType) => factoryParamTestValue(pType))
+        .join(", ");
+      lines.push(`    it("should create instance via ${factory.name}() factory", () => {`);
+      lines.push(`      const instance = ${typeName}.${factory.name}(${paramValues});`);
+      lines.push(`      expect(instance).toBeDefined();`);
+      lines.push(`      expect(instance).toBeInstanceOf(${typeName});`);
+      for (const [propName, value] of Object.entries(factory.sets)) {
+        if (value === true) {
+          lines.push(`      expect(instance.${propName}).toBe(true);`);
+        } else if (value === false) {
+          lines.push(`      expect(instance.${propName}).toBe(false);`);
+        } else if (typeof value === "number") {
+          lines.push(`      expect(instance.${propName}).toBe(${value});`);
+        } else if (typeof value === "string") {
+          lines.push(`      expect(instance.${propName}).toBe("${value}");`);
+        }
+      }
+      lines.push(`    });`);
+    }
+    lines.push(`  });`);
+  }
+
+  // Load and save
+  lines.push("");
+  if (!(isAbstract && node.isAbstract)) {
+    lines.push(`  describe("load and save", () => {`);
+    if (!isAbstract) {
+      lines.push(`    it("should load from dictionary", () => {`);
+      lines.push(`      const data: Record<string, unknown> = {};`);
+      lines.push(`      const instance = ${typeName}.load(data);`);
+      lines.push(`      expect(instance).toBeDefined();`);
+      lines.push(`    });`);
+    }
+    lines.push("");
+    if (!node.isAbstract) {
+      lines.push(`    it("should save to dictionary", () => {`);
+      lines.push(`      const instance = new ${typeName}();`);
+      lines.push(`      const data = instance.save();`);
+      lines.push(`      expect(data).toBeDefined();`);
+      lines.push(`      expect(typeof data).toBe("object");`);
+      lines.push(`    });`);
+    }
+    lines.push(`  });`);
+  }
+  lines.push("});");
+  lines.push("");
+
+  return lines.join("\n");
+}
diff --git a/schema/emitter/src/languages/typescript/visitor.ts b/schema/emitter/src/languages/typescript/visitor.ts
new file mode 100644
index 00000000..ecb0705a
--- /dev/null
+++ b/schema/emitter/src/languages/typescript/visitor.ts
@@ -0,0 +1,76 @@
+/**
+ * TypeScript expression visitor — Expr IR → TypeScript source fragments.
+ */
+
+import { Expr, Construct, VariantConstruct, ArrayLiteral, TypeRegistry } from "../../ir/expansion.js";
+import { ExprVisitor, assertNever } from "../../ir/visitor.js";
+
+export class TypeScriptExprVisitor implements ExprVisitor {
+  registry?: TypeRegistry;
+
+  constructor(registry?: TypeRegistry) {
+    this.registry = registry;
+  }
+
+  visitExpr(expr: Expr): string {
+    switch (expr.kind) {
+      case "string":
+        return `"${this.escapeString(expr.value)}"`;
+      case "number":
+        return String(expr.value);
+      case "boolean":
+        return expr.value ? "true" : "false";
+      case "null":
+        return "undefined";
+      case "param":
+        return expr.name;
+      case "construct":
+        return this.visitConstruct(expr);
+      case "variant":
+        return this.visitVariant(expr);
+      case "array":
+        return this.visitArray(expr);
+      case "dict":
+        return `{ ${expr.entries.map(e => `${e.key}: ${this.visitExpr(e.value)}`).join(", ")} }`;
+      case "field_read":
+        return `${expr.objectName}.${expr.fieldName}`;
+      default:
+        return assertNever(expr);
+    }
+  }
+
+  private visitConstruct(expr: Construct): string {
+    const typeName = expr.typeName.name;
+    if (expr.fields.length === 0) {
+      return `new ${typeName}({})`;
+    }
+    const fields = expr.fields.map(f =>
+      `${f.propertyName}: ${this.visitExpr(f.value)}`
+    ).join(", ");
+    return `new ${typeName}({ ${fields} })`;
+  }
+
+  private visitVariant(expr: VariantConstruct): string {
+    // In TypeScript, polymorphic children are full classes — construct the variant type directly
+    const variantName = expr.variantTypeName.name;
+    if (expr.fields.length === 0) {
+      return `new ${variantName}({})`;
+    }
+    const fields = expr.fields.map(f =>
+      `${f.propertyName}: ${this.visitExpr(f.value)}`
+    ).join(", ");
+    return `new ${variantName}({ ${fields} })`;
+  }
+
+  private visitArray(expr: ArrayLiteral): string {
+    if (expr.items.length === 0) {
+      return "[]";
+    }
+    const items = expr.items.map(i => this.visitExpr(i)).join(", ");
+    return `[${items}]`;
+  }
+
+  private escapeString(s: string): string {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+}
diff --git a/schema/emitter/src/lib.ts b/schema/emitter/src/lib.ts
index eb9ae245..9520fbf1 100644
--- a/schema/emitter/src/lib.ts
+++ b/schema/emitter/src/lib.ts
@@ -16,6 +16,7 @@ export interface PromptyEmitterOptions {
   "root-alias"?: string;
   "omit-models"?: string[];
   "schema-output-dir"?: string;
+  "additional-roots"?: string[];
 }
 
 const PromptyEmitterOptionsSchema: JSONSchemaType<PromptyEmitterOptions> = {
@@ -90,19 +91,30 @@ const PromptyEmitterOptionsSchema: JSONSchemaType<PromptyEmitterOptions> = {
       type: "string",
       nullable: true,
       description: "Directory containing JSON schema files. If set, omitted models will be deleted from this directory after generation."
+    },
+    "additional-roots": {
+      type: "array",
+      items: { type: "string" },
+      nullable: true,
+      description: "Additional root types to resolve and generate alongside the main root object. These types need not be referenced from the main root. Specified as fully-qualified names (e.g., 'Prompty.Message')."
     }
   },
   required: ["root-object"],
 };
 
 export const $lib = createTypeSpecLibrary({
-  name: "agentschema-emitter",
+  name: "prompty-emitter",
   diagnostics: {},
   emitter: { options: PromptyEmitterOptionsSchema },
   state: {
     samples: { description: "Sample values for properties" },
-    shorthands: { description: "Shorthand models creation" },
-    abstracts: { description: "Abstract models" }
+    coercions: { description: "Scalar-to-object implicit conversions" },
+    abstracts: { description: "Abstract models" },
+    factories: { description: "Factory methods for model construction" },
+    methods: { description: "Method stubs for model types" },
+    knownAs: { description: "Wire field name mappings per target system" },
+    defaultFor: { description: "Per-target required default values" },
+    protocols: { description: "Pipeline interface markers" }
   }
 });
 
diff --git a/schema/emitter/src/lib/main.tsp b/schema/emitter/src/lib/main.tsp
index c4ae9c73..a5e2a8d9 100644
--- a/schema/emitter/src/lib/main.tsp
+++ b/schema/emitter/src/lib/main.tsp
@@ -6,25 +6,17 @@ using TypeSpec.Reflection;
  */
 extern dec sample(target: ModelProperty, sample: valueof unknown);
 
-/**
- * Adds an alternate sample to the target model property, with an expansion description.
- */
-extern dec alternate(
-  target: ModelProperty,
-  `scalar`: Scalar,
-  sample: valueof unknown,
-  expansion: valueof unknown
-);
-
 /**
  * Marks the target model as abstract, preventing direct instantiation.
  */
 extern dec abstract(target: Model);
 
 /**
- * Marks the target model as a shorthand for another model, providing a scalar type and expansion description.
+ * Marks the target model as having a scalar-to-object implicit conversion.
+ * When a scalar value is encountered during deserialization, it is expanded
+ * into a full object using the provided expansion template.
  */
-extern dec shorthand(
+extern dec coerce(
   target: Model,
   `scalar`: Scalar,
   expansion: valueof unknown,
@@ -32,3 +24,87 @@ extern dec shorthand(
   description?: valueof string,
   example?: valueof unknown
 );
+
+/**
+ * Declares a factory method on the target model. Factory methods are fully
+ * generated — the emitter produces both signature and body. The `sets` parameter
+ * specifies which fields to assign and their values. The optional `params`
+ * parameter specifies method parameters (name → type string).
+ *
+ * @example
+ * ```typespec
+ * @@factory("allow", #{ allowed: true })
+ * @@factory("deny", #{ allowed: false }, #{ reason: "string" })
+ * ```
+ */
+extern dec factory(
+  target: Model,
+  name: valueof string,
+  sets: valueof unknown,
+  params?: valueof unknown
+);
+
+/**
+ * Declares a method stub on the target model. Method stubs are
+ * stub-generated — the emitter produces the signature in the generated file
+ * and a create-if-missing extension file where the body must be hand-written.
+ * This enforces that every runtime implements the method (compile/test failure
+ * if missing) while allowing language-idiomatic implementations.
+ *
+ * The optional `params` parameter specifies method parameters (name → type string).
+ * When used on `@protocol` models, params drive the generated interface method
+ * signatures.
+ *
+ * @example
+ * ```typespec
+ * @@method("text", "string", "Concatenate all TextPart values joined by newline")
+ * @@method("render", "string", "Render template with inputs", #{ agent: "Prompty", template: "string", inputs: "Record<unknown>" })
+ * ```
+ */
+extern dec method(
+  target: Model,
+  name: valueof string,
+  returns: valueof string,
+  description?: valueof string,
+  params?: valueof unknown,
+  optional?: valueof boolean,
+  sync?: valueof boolean
+);
+
+/**
+ * Maps a property's wire name for a specific provider. Used in provider
+ * wire.tsp files via augment syntax (`@@`) to declare how core property names
+ * map to provider-specific API parameter names.
+ *
+ * @param provider The target provider identifier (e.g., "openai", "anthropic")
+ * @param name The wire field name used by that provider's API
+ *
+ * @example
+ * ```typespec
+ * @@knownAs(ModelOptions.maxOutputTokens, "openai", "max_completion_tokens")
+ * @@knownAs(ModelOptions.maxOutputTokens, "anthropic", "max_tokens")
+ * ```
+ */
+extern dec knownAs(target: ModelProperty, provider: valueof string, name: valueof string);
+
+/**
+ * Declares a per-provider required default value for a property. Used in provider
+ * wire.tsp files via augment syntax (`@@`) when a provider requires a value that
+ * the core schema treats as optional.
+ *
+ * @param provider The target provider identifier (e.g., "openai", "anthropic")
+ * @param defaultValue The default value for that provider
+ *
+ * @example
+ * ```typespec
+ * @@defaultFor(ModelOptions.maxOutputTokens, "openai", 4096)
+ * ```
+ */
+extern dec defaultFor(target: ModelProperty, provider: valueof string, defaultValue: valueof unknown);
+
+/**
+ * Marks the target model as a protocol interface. Protocol interfaces define
+ * the pipeline stage contracts (renderer, parser, executor, processor). The
+ * emitter generates language-appropriate interface/trait/protocol definitions.
+ */
+extern dec protocol(target: Model);
diff --git a/schema/emitter/src/markdown.ts b/schema/emitter/src/markdown.ts
deleted file mode 100644
index 3643d5b9..00000000
--- a/schema/emitter/src/markdown.ts
+++ /dev/null
@@ -1,172 +0,0 @@
-import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
-import { EmitTarget, PromptyEmitterOptions } from "./lib.js";
-import { enumerateTypes, PropertyNode, TypeName, TypeNode } from "./ast.js";
-import { GeneratorOptions, filterNodes } from "./emitter.js";
-import * as nunjucks from "nunjucks";
-import * as YAML from 'yaml';
-import path from "path";
-
-function deepMerge<T extends Record<string, any>>(...objects: T[]): T {
-  return objects.reduce((acc, obj) => {
-    Object.keys(obj).forEach((key) => {
-      const accValue = acc[key as keyof T];
-      const objValue = obj[key as keyof T];
-
-      if (typeof accValue === "object" && typeof objValue === "object") {
-        acc[key as keyof T] = deepMerge(accValue, objValue);
-      } else {
-        acc[key as keyof T] = objValue;
-      }
-    });
-    return acc;
-  }, {} as T);
-}
-
-export const generateMarkdown = async (context: EmitContext<PromptyEmitterOptions>, templateDir: string, node: TypeNode, emitTarget: EmitTarget, options?: GeneratorOptions) => {
-
-  const rootObject = context.options["root-alias"] || "AgentDefinition";
-  // set up template environment
-  const templatePath = path.resolve(templateDir, 'markdown');
-  const env = new nunjucks.Environment(new nunjucks.FileSystemLoader(templatePath));
-  const template = env.getTemplate('file.md.njk', true);
-  const readme = env.getTemplate('index.md.njk', true);
-
-  const nodes = filterNodes(Array.from(enumerateTypes(node)), options);
-
-  const childTypes: { source: string, target: string }[] = nodes.map(n => {
-    return n.childTypes.map(c => {
-      return { source: n.typeName.name, target: c.typeName.name };
-    });
-  }).flat();
-
-  const compositionTypes: { source: string, target: string }[] = nodes.map(n => {
-    return n.properties.filter(p => !p.isScalar).map(c => {
-      return { source: n.typeName.name, target: c.typeName.name };
-    });
-  }).flat();
-
-  const readmeContent = readme.render({
-    types: nodes,
-    rootObject: rootObject,
-    childTypes: childTypes,
-    compositionTypes: compositionTypes
-  });
-
-  await emitMarkdownFile(context, "index", readmeContent, emitTarget["output-dir"]);
-
-  const findNodeByName = (name: TypeName): TypeNode | undefined => {
-    return nodes.find(n => n.typeName.name === name.name && n.typeName.namespace === name.namespace);
-  }
-
-  for (const node of nodes) {
-    const sample = node.properties.filter(p => p.samples.length > 0).map(p => p.samples[0].sample);
-    let yml: string | undefined = undefined;
-    let md: string | undefined = undefined;
-    if (sample.length > 0) {
-      const s = deepMerge(...sample);
-      yml = YAML.stringify(s, { indent: 2 });
-      if ("instructions" in s) {
-        const instructions = s.instructions;
-        delete s.instructions;
-        md = `---\n${YAML.stringify(s, { indent: 2 })}---\n${instructions}`;
-      }
-    }
-    const markdown = template.render({
-      node: node,
-      yml: yml,
-      md: md,
-      renderType: renderType,
-      renderChildTypes: renderChildTypes,
-      compositionTypes: getCompositionTypes(node),
-      alternateCtors: generateAlternates(node),
-      parent: node.base ? findNodeByName(node.base) : undefined,
-    });
-
-    await emitMarkdownFile(context, node.typeName.name, markdown, emitTarget["output-dir"]);
-  }
-}
-
-export const renderType = (prop: PropertyNode) => {
-  const arrayString = prop.isCollection ? "[]" : "";
-  if (prop.isScalar) {
-    return prop.typeName.name + arrayString;
-  } else if (prop.isDict) {
-    return `${prop.typeName.name + arrayString}`;
-  } else {
-    return `[${prop.typeName.name + arrayString}](../${prop.typeName.name.toLowerCase()}/)`;
-  }
-};
-
-export const renderChildTypes = (node: PropertyNode) => {
-  if (!node.isScalar && node.type) {
-    const childTypes = node.type.childTypes.map(c => {
-      return `[${c.typeName.name}](../${c.typeName.name.toLowerCase()}/)`;
-    });
-
-    if (childTypes.length === 0) {
-      return "";
-    }
-
-    return `(Related Types: ${childTypes.join(", ")})`;
-  }
-  return "";
-};
-
-export const getChildTypes = (node: TypeNode): { source: string, target: string }[] => {
-  return node.childTypes.flatMap(c => [{
-    source: node.typeName.name,
-    target: c.typeName.name
-  }, ...getChildTypes(c)]);
-};
-
-export const getCompositionTypes = (node: TypeNode): TypeNode[] => {
-  const nonScalars = node.properties.filter(p => !p.isScalar && !p.isDict);
-  return nonScalars.flatMap(c => c.type ? [c.type] : []);
-};
-
-const typeExampleMapper: Record<string, string> = {
-  "string": "\"example\"",
-  "number": "5",
-  "boolean": "true",
-  "int64": "5",
-  "int32": "5",
-  "float64": "3.14",
-  "float32": "3.14",
-  "integer": "5",
-  "float": "3.14",
-  "numeric": "3.14",
-};
-
-export const generateAlternates = (node: TypeNode): { title: string; description: string; scalar: string; simple: string, expanded: string }[] => {
-  if (node.alternates && node.alternates.length > 0) {
-    const alts: { title: string; description: string; scalar: string; simple: string, expanded: string }[] = [];
-    for (const alt of node.alternates) {
-      const scalar = alt.scalar;
-      const sample = typeExampleMapper[scalar] ? typeExampleMapper[scalar] : "example";
-
-      const simple: { [key: string]: any } = {};
-      simple[alt.title || "value"] = "\"{value}\"";
-      const expansion: { [key: string]: any } = {};
-      expansion[alt.title || "value"] = alt.expansion;
-
-      alts.push({
-        title: alt.title || "",
-        description: alt.description || "",
-        scalar: scalar,
-        simple: YAML.stringify(simple, { indent: 2 }).replace("\"{value}\"", sample).replaceAll("'", ""),
-        expanded: YAML.stringify(expansion, { indent: 2 }).replace("\"{value}\"", sample)
-      });
-    }
-    return alts;
-  } else {
-    return [];
-  }
-};
-
-const emitMarkdownFile = async (context: EmitContext<PromptyEmitterOptions>, name: string, markdown: string, outputDir?: string) => {
-  const dir = outputDir || `${context.emitterOutputDir}/markdown`;
-  await emitFile(context.program, {
-    path: resolvePath(dir, `${name}.md`),
-    content: markdown,
-  });
-}
diff --git a/schema/emitter/src/rust.ts b/schema/emitter/src/rust.ts
deleted file mode 100644
index bb91b3e2..00000000
--- a/schema/emitter/src/rust.ts
+++ /dev/null
@@ -1,398 +0,0 @@
-import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
-import { execSync } from "child_process";
-import { existsSync } from "fs";
-import { resolve } from "path";
-import { EmitTarget, PromptyEmitterOptions } from "./lib.js";
-import {
-  BaseTestContext,
-  enumerateTypes,
-  PropertyNode,
-  TypeNode,
-} from "./ast.js";
-import { GeneratorOptions, filterNodes } from "./emitter.js";
-import { createTemplateEngine } from "./template-engine.js";
-import { buildBaseTestContext, rustTestOptions } from "./test-context.js";
-import { toSnakeCase } from "./utilities.js";
-
-/**
- * Type mapping from TypeSpec scalar types to Rust types.
- */
-export const rustTypeMapper: Record<string, string> = {
-  "string": "String",
-  "number": "f64",
-  "array": "Vec<serde_json::Value>",
-  "object": "serde_json::Value",
-  "boolean": "bool",
-  "int64": "i64",
-  "int32": "i32",
-  "float64": "f64",
-  "float32": "f32",
-  "integer": "i64",
-  "float": "f64",
-  "numeric": "f64",
-  "any": "serde_json::Value",
-  "dictionary": "serde_json::Value",
-};
-
-/**
- * Data describing a polymorphic enum variant for Rust codegen.
- */
-interface PolymorphicVariant {
-  /** PascalCase variant name (e.g., "Function") */
-  variantName: string;
-  /** Discriminator value from TypeSpec (e.g., "function"), or "*" for wildcard */
-  kindValue: string;
-  /** Whether this is the wildcard/default variant (kind value "*") */
-  isWildcard: boolean;
-  /** Variant-only properties (excluding base properties and discriminator) */
-  properties: PropertyNode[];
-  /** Doc comment for this variant */
-  description: string;
-}
-
-/**
- * Rust context interfaces for template rendering
- */
-interface RustClassContext {
-  node: TypeNode;
-  typeMapper: Record<string, string>;
-  alternates: Array<{ scalar: string; alternate: string }>;
-  polymorphicTypes: any;
-  imports: string[];
-  collectionTypes: Array<{ prop: PropertyNode; type: string[] }>;
-  shorthandProperty: string | null;
-  // Polymorphic support
-  isPolymorphicBase: boolean;
-  isPolymorphicChild: boolean;
-  discriminatorField: string | undefined;
-  enumName: string | undefined;
-  variants: PolymorphicVariant[];
-  basePropertiesWithoutDiscriminator: PropertyNode[];
-}
-
-interface RustFileContext {
-  containsAbstract: boolean;
-  imports: string[];
-  classes: RustClassContext[];
-  typeMapper: Record<string, string>;
-  polymorphicTypeNames: string[];
-}
-
-interface RustContextContext {
-  header: string;
-}
-
-interface RustLibContext {
-  modules: string[];
-}
-
-/**
- * Main entry point for Rust code generation.
- */
-export const generateRust = async (
-  context: EmitContext<PromptyEmitterOptions>,
-  templateDir: string,
-  node: TypeNode,
-  emitTarget: EmitTarget,
-  options?: GeneratorOptions
-): Promise<void> => {
-  const engine = createTemplateEngine(templateDir, 'rust');
-  const nodes = filterNodes(Array.from(enumerateTypes(node)), options);
-
-  // Collect all polymorphic type names across all nodes
-  const polymorphicTypeNames = new Set<string>();
-  const polymorphicChildNames = new Set<string>();
-  for (const n of nodes) {
-    const polyTypes = n.retrievePolymorphicTypes();
-    if (polyTypes) {
-      polymorphicTypeNames.add(n.typeName.name);
-      for (const child of n.childTypes) {
-        polymorphicChildNames.add(child.typeName.name);
-      }
-    }
-  }
-
-  // Render context.rs
-  const contextContext = buildContextContext();
-  const contextContent = engine.render('context.rs.njk', contextContext);
-  await emitRustFile(context, 'context.rs', contextContent, emitTarget["output-dir"]);
-
-  // Render each base type and its children as a single file
-  const moduleNames: string[] = ['context'];
-  const testModuleNames: string[] = [];
-  for (const n of nodes) {
-    if (!n.base) {
-      const fileContext = buildFileContext(n, polymorphicTypeNames);
-      const fileContent = engine.render('file.rs.njk', fileContext);
-      const fileName = toSnakeCase(n.typeName.name) + '.rs';
-      await emitRustFile(context, fileName, fileContent, emitTarget["output-dir"]);
-      moduleNames.push(toSnakeCase(n.typeName.name));
-    }
-
-    // Render test file — skip children of polymorphic hierarchies (they're enum variants now)
-    if (emitTarget["test-dir"] && !polymorphicChildNames.has(n.typeName.name)) {
-      const importPath = emitTarget["import-path"] || "crate";
-      const testContext = buildTestContext(n);
-      const isPolymorphicBase = !!(n.discriminator && n.childTypes.length > 0);
-      const testContent = engine.render('test.rs.njk', {
-        ...testContext,
-        importPath,
-        isPolymorphicBase,
-      });
-      const testFileName = toSnakeCase(n.typeName.name) + '_test.rs';
-      await emitRustFile(context, testFileName, testContent, emitTarget["test-dir"]);
-      testModuleNames.push(toSnakeCase(n.typeName.name) + '_test');
-    }
-  }
-
-  // Render test main.rs (module declarations for the test harness)
-  if (emitTarget["test-dir"]) {
-    const mainContent = '// Code generated by AgentSchema emitter; DO NOT EDIT.\n\n'
-      + testModuleNames.map(m => `mod ${m};`).join('\n') + '\n';
-    await emitRustFile(context, 'main.rs', mainContent, emitTarget["test-dir"]);
-  }
-
-  // Render mod.rs (module declarations for embedding as a submodule)
-  const libContext: RustLibContext = { modules: moduleNames };
-  const libContent = engine.render('lib.rs.njk', libContext);
-  await emitRustFile(context, 'mod.rs', libContent, emitTarget["output-dir"]);
-
-  // Format emitted files
-  if (emitTarget.format !== false) {
-    const outputDir = emitTarget["output-dir"]
-      ? resolve(process.cwd(), emitTarget["output-dir"])
-      : context.emitterOutputDir;
-    formatRustFiles(outputDir);
-  }
-};
-
-/**
- * Format Rust files using cargo fmt.
- */
-function formatRustFiles(outputDir: string): void {
-  // Run cargo fmt if Cargo.toml exists in parent
-  const cargoToml = resolve(outputDir, '../Cargo.toml');
-  if (existsSync(cargoToml)) {
-    try {
-      execSync(`cargo fmt --manifest-path "${cargoToml}"`, {
-        stdio: 'pipe',
-        encoding: 'utf-8'
-      });
-    } catch (error) {
-      console.warn(`Warning: cargo fmt failed. You may need to install Rust.`);
-    }
-  }
-}
-
-/**
- * Build context for rendering a single Rust struct.
- */
-function buildClassContext(node: TypeNode, polymorphicTypeNames: Set<string>): RustClassContext {
-  const isPolymorphicBase = !!(node.discriminator && node.childTypes.length > 0);
-  const isPolymorphicChild = !!(node.base && polymorphicTypeNames.has(node.base.name));
-
-  let discriminatorField: string | undefined;
-  let enumName: string | undefined;
-  let variants: PolymorphicVariant[] = [];
-  let basePropertiesWithoutDiscriminator: PropertyNode[] = [];
-
-  if (isPolymorphicBase) {
-    discriminatorField = node.discriminator!;
-    enumName = node.typeName.name + 'Kind';
-    basePropertiesWithoutDiscriminator = node.properties.filter(
-      p => p.name !== node.discriminator
-    );
-
-    const polyTypes = node.retrievePolymorphicTypes();
-    if (polyTypes) {
-      const basePropertyNames = new Set(node.properties.map(p => p.name));
-
-      // Named variants (non-wildcard)
-      for (const t of polyTypes.types) {
-        const childNode = t.instance as TypeNode;
-        const vName = childNode.typeName.name.replace(node.typeName.name, '') || childNode.typeName.name;
-        const variantProps = childNode.properties.filter(
-          (p: PropertyNode) => p.name !== node.discriminator && !basePropertyNames.has(p.name)
-        );
-        variants.push({
-          variantName: vName,
-          kindValue: t.value,
-          isWildcard: false,
-          properties: variantProps,
-          description: childNode.description || '',
-        });
-      }
-
-      // Wildcard/default variant
-      if (polyTypes.default) {
-        const defaultNode = polyTypes.default.instance as TypeNode;
-        const isSelfRef = defaultNode.typeName.name === node.typeName.name;
-        const defaultName = isSelfRef
-          ? 'Custom'
-          : (defaultNode.typeName.name.replace(node.typeName.name, '') || 'Custom');
-        const defaultProps = isSelfRef
-          ? []
-          : defaultNode.properties.filter(
-              (p: PropertyNode) => p.name !== node.discriminator && !basePropertyNames.has(p.name)
-            );
-        variants.push({
-          variantName: defaultName,
-          kindValue: polyTypes.default.value,
-          isWildcard: true,
-          properties: defaultProps,
-          description: defaultNode.description || 'Wildcard variant for unknown kinds.',
-        });
-      }
-    }
-  }
-
-  return {
-    node,
-    typeMapper: rustTypeMapper,
-    alternates: prepareAlternates(node),
-    polymorphicTypes: node.retrievePolymorphicTypes(),
-    imports: getUniqueImportTypes(node, polymorphicTypeNames),
-    collectionTypes: getCollectionTypes(node),
-    shorthandProperty: getShorthandProperty(node),
-    isPolymorphicBase,
-    isPolymorphicChild,
-    discriminatorField,
-    enumName,
-    variants,
-    basePropertiesWithoutDiscriminator,
-  };
-}
-
-/**
- * Build context for rendering a Rust file with a base type and its children.
- */
-function buildFileContext(node: TypeNode, polymorphicTypeNames: Set<string>): RustFileContext {
-  const classes: RustClassContext[] = [
-    buildClassContext(node, polymorphicTypeNames),
-    ...node.childTypes.map(ct => buildClassContext(ct, polymorphicTypeNames))
-  ];
-
-  // Collect unique imports from all classes, excluding types defined in this file
-  // and skipping child classes (they're inline enum variants, not rendered as structs)
-  const definedInFile = new Set([node.typeName.name, ...node.childTypes.map(c => c.typeName.name)]);
-  const allImports = new Set<string>();
-  for (const cls of classes) {
-    if (cls.isPolymorphicChild) continue;
-    for (const imp of cls.imports) {
-      if (!definedInFile.has(imp)) {
-        allImports.add(imp);
-      }
-    }
-  }
-
-  return {
-    containsAbstract: node.isAbstract || node.childTypes.some(c => c.isAbstract),
-    imports: Array.from(allImports).sort(),
-    classes,
-    typeMapper: rustTypeMapper,
-    polymorphicTypeNames: Array.from(polymorphicTypeNames),
-  };
-}
-
-/**
- * Build context for rendering a test file.
- */
-function buildTestContext(node: TypeNode): BaseTestContext {
-  return buildBaseTestContext(node, undefined, rustTestOptions);
-}
-
-/**
- * Build context for rendering the context.rs file.
- */
-function buildContextContext(): RustContextContext {
-  return { header: "Prompty Context" };
-}
-
-/**
- * Prepare alternate representations for template rendering.
- */
-function prepareAlternates(node: TypeNode): Array<{ scalar: string; alternate: string }> {
-  if (!node.alternates || node.alternates.length === 0) {
-    return [];
-  }
-
-  return node.alternates.map(alt => ({
-    scalar: rustTypeMapper[alt.scalar] || alt.scalar,
-    alternate: JSON.stringify(alt.expansion, null, '')
-      .replaceAll('\n', '')
-      .replaceAll('"{value}"', 'value'),
-  }));
-}
-
-/**
- * Get the shorthand property name from alternates.
- */
-function getShorthandProperty(node: TypeNode): string | null {
-  if (!node.alternates || node.alternates.length === 0) {
-    return null;
-  }
-  for (const alt of node.alternates) {
-    for (const [key, value] of Object.entries(alt.expansion)) {
-      if (value === "{value}") {
-        return key;
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Get collection properties with their nested type info.
- */
-function getCollectionTypes(node: TypeNode): Array<{ prop: PropertyNode; type: string[] }> {
-  return node.properties
-    .filter(p => p.isCollection && !p.isScalar && !p.isDict)
-    .map(p => ({
-      prop: p,
-      type: p.type?.properties.filter(t => t.name !== "name").map(t => t.name) || [],
-    }));
-}
-
-/**
- * Get unique import types needed from other modules.
- * Excludes polymorphic types that are not collection fields (stored as serde_json::Value
- * with no typed accessor method).
- */
-function getUniqueImportTypes(node: TypeNode, polymorphicTypeNames: Set<string>): string[] {
-  const isPolyBase = !!(node.discriminator && node.childTypes.length > 0);
-  const imports = [
-    node.properties
-      .filter(p => !p.isScalar && !p.isDict)
-      // For polymorphic types: only import if it's a collection (needed for typed accessor)
-      .filter(p => !polymorphicTypeNames.has(p.typeName.name) || p.isCollection)
-      .map(p => p.typeName.name),
-    ...node.childTypes.flatMap(c =>
-      c.properties
-        .filter(p => !p.isScalar && !p.isDict)
-        // Child properties in enum variants: non-scalar collections and polymorphic types
-        // become serde_json::Value, so skip those imports
-        .filter(p => !polymorphicTypeNames.has(p.typeName.name))
-        .filter(p => !isPolyBase || !p.isCollection)
-        .map(p => p.typeName.name)
-    )
-  ].flat().filter(n => n !== node.typeName.name && node.base?.name !== n);
-
-  return Array.from(new Set(imports)).sort();
-}
-
-/**
- * Write generated Rust content to file.
- */
-async function emitRustFile(
-  context: EmitContext<PromptyEmitterOptions>,
-  filename: string,
-  content: string,
-  outputDir?: string
-): Promise<void> {
-  outputDir = outputDir || `${context.emitterOutputDir}/rust`;
-  const filePath = resolvePath(outputDir, filename);
-  await emitFile(context.program, {
-    path: filePath,
-    content,
-  });
-}
diff --git a/schema/emitter/src/template-engine.ts b/schema/emitter/src/template-engine.ts
deleted file mode 100644
index 1da1a06c..00000000
--- a/schema/emitter/src/template-engine.ts
+++ /dev/null
@@ -1,208 +0,0 @@
-import * as nunjucks from "nunjucks";
-import path from "path";
-
-/**
- * A unified template engine that encapsulates Nunjucks setup and provides
- * a consistent API for all language emitters.
- * 
- * Features:
- * - Multiple loader paths for shared macros access
- * - Registered custom filters (camelCase, snakeCase, pascalCase, etc.)
- * - Clean render API that accepts pure data contexts (no functions)
- */
-export class TemplateEngine {
-  private env: nunjucks.Environment;
-  private templateCache: Map<string, nunjucks.Template> = new Map();
-
-  /**
-   * Create a new TemplateEngine for a specific language.
-   * 
-   * @param templateDir - Base template directory (e.g., 'src/templates')
-   * @param language - Language subdirectory (e.g., 'python', 'csharp')
-   */
-  constructor(templateDir: string, language: string) {
-    const languageDir = path.resolve(templateDir, language);
-    const sharedDir = path.resolve(templateDir, '_shared');
-
-    // Configure loader with multiple paths:
-    // 1. Language-specific templates first
-    // 2. Shared macros second (allows {% from "macros.njk" %} without relative path)
-    const loader = new nunjucks.FileSystemLoader([languageDir, sharedDir], {
-      watch: false,
-      noCache: false,
-    });
-
-    this.env = new nunjucks.Environment(loader, {
-      autoescape: false,  // Don't escape output - we're generating code, not HTML
-      trimBlocks: false,  // Don't remove newlines after block tags - we want control
-      lstripBlocks: false, // Keep indentation before block tags
-    });
-
-    // Register custom filters
-    this.registerFilters();
-  }
-
-  /**
-   * Register custom Nunjucks filters for common transformations.
-   */
-  private registerFilters(): void {
-    // camelCase: "hello_world" -> "helloWorld"
-    this.env.addFilter('camelCase', (str: string): string => {
-      if (!str) return str;
-      return str
-        .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
-        .replace(/^(.)/, (_, char) => char.toLowerCase());
-    });
-
-    // PascalCase: "hello_world" -> "HelloWorld", "helloWorld" -> "HelloWorld"
-    this.env.addFilter('pascalCase', (str: string): string => {
-      if (!str) return str;
-      
-      // First handle snake_case and kebab-case
-      if (str.includes('_') || str.includes('-')) {
-        return str
-          .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
-          .replace(/^(.)/, (_, char) => char.toUpperCase());
-      }
-      
-      // Handle camelCase by inserting boundaries at uppercase letters
-      const withBoundaries = str.replace(/([a-z])([A-Z])/g, '$1_$2');
-      return withBoundaries
-        .split('_')
-        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
-        .join('');
-    });
-
-    // snake_case: "helloWorld" -> "hello_world"
-    this.env.addFilter('snakeCase', (str: string): string => {
-      if (!str) return str;
-      return str
-        .replace(/([A-Z])/g, '_$1')
-        .toLowerCase()
-        .replace(/^_/, '');
-    });
-
-    // kebab-case: "helloWorld" -> "hello-world"
-    this.env.addFilter('kebabCase', (str: string): string => {
-      if (!str) return str;
-      return str
-        .replace(/([A-Z])/g, '-$1')
-        .toLowerCase()
-        .replace(/^-/, '');
-    });
-
-    // JSON stringify with optional formatting
-    this.env.addFilter('jsonStringify', (obj: any, indent?: number): string => {
-      return JSON.stringify(obj, null, indent);
-    });
-
-    // Indent each line of a string
-    this.env.addFilter('indent', (str: string, spaces: number): string => {
-      if (!str) return str;
-      const indent = ' '.repeat(spaces);
-      return str.split('\n').map(line => indent + line).join('\n');
-    });
-
-    // Wrap text in comment style
-    this.env.addFilter('wrapComment', (str: string, prefix: string = '# '): string => {
-      if (!str) return str;
-      return str.split('\n').map(line => prefix + line).join('\n');
-    });
-
-    // Python-specific: convert boolean to Python bool
-    this.env.addFilter('pythonBool', (val: boolean): string => {
-      return val ? 'True' : 'False';
-    });
-
-    // Filter array by property
-    this.env.addFilter('where', (arr: any[], prop: string, value: any): any[] => {
-      if (!arr) return arr;
-      return arr.filter(item => item[prop] === value);
-    });
-
-    // Filter array where property is truthy
-    this.env.addFilter('whereTruthy', (arr: any[], prop: string): any[] => {
-      if (!arr) return arr;
-      return arr.filter(item => item[prop]);
-    });
-
-    // Filter array where property is falsy
-    this.env.addFilter('whereFalsy', (arr: any[], prop: string): any[] => {
-      if (!arr) return arr;
-      return arr.filter(item => !item[prop]);
-    });
-
-    // Get unique values from array by property
-    this.env.addFilter('unique', (arr: any[], prop?: string): any[] => {
-      if (!arr) return arr;
-      if (prop) {
-        const seen = new Set();
-        return arr.filter(item => {
-          const val = item[prop];
-          if (seen.has(val)) return false;
-          seen.add(val);
-          return true;
-        });
-      }
-      return [...new Set(arr)];
-    });
-
-    // Map lookup - useful for type mapping
-    this.env.addFilter('lookup', (key: string, map: Record<string, string>, defaultValue?: string): string => {
-      return map[key] ?? defaultValue ?? key;
-    });
-  }
-
-  /**
-   * Get a template by name, with caching.
-   */
-  getTemplate(name: string): nunjucks.Template {
-    let template = this.templateCache.get(name);
-    if (!template) {
-      template = this.env.getTemplate(name, true);
-      this.templateCache.set(name, template);
-    }
-    return template;
-  }
-
-  /**
-   * Render a template with the given context.
-   * 
-   * @param templateName - Name of the template file (e.g., 'class.njk')
-   * @param context - Pure data context (no functions - all logic should be in macros)
-   * @returns The rendered string
-   */
-  render(templateName: string, context: Record<string, any>): string {
-    const template = this.getTemplate(templateName);
-    return template.render(context);
-  }
-
-  /**
-   * Render a template string directly (useful for inline templates).
-   */
-  renderString(templateStr: string, context: Record<string, any>): string {
-    return this.env.renderString(templateStr, context);
-  }
-
-  /**
-   * Add a custom filter to this engine instance.
-   */
-  addFilter(name: string, fn: (...args: any[]) => any): void {
-    this.env.addFilter(name, fn);
-  }
-
-  /**
-   * Add a custom global variable/function available to all templates.
-   */
-  addGlobal(name: string, value: any): void {
-    this.env.addGlobal(name, value);
-  }
-}
-
-/**
- * Factory function to create a TemplateEngine for a specific language.
- * This is the recommended way to create engines in emitters.
- */
-export function createTemplateEngine(templateDir: string, language: string): TemplateEngine {
-  return new TemplateEngine(templateDir, language);
-}
diff --git a/schema/emitter/src/templates/_shared/macros.njk b/schema/emitter/src/templates/_shared/macros.njk
deleted file mode 100644
index ef264e07..00000000
--- a/schema/emitter/src/templates/_shared/macros.njk
+++ /dev/null
@@ -1,167 +0,0 @@
-{#
-  Shared Macros for AgentSchema Emitters
-  ======================================
-
-  These macros provide language-agnostic utilities for property filtering,
-  type checking, and common rendering patterns. Language-specific emitters
-  should import and use these macros for consistency.
-
-  Usage in language templates:
-    {% from "macros.njk" import requiredProps, optionalProps %}
-#}
-
-{# ============================================================================
-   Property Filtering Macros
-   ============================================================================ #}
-
-{#
-  Get required (non-optional) properties from a list.
-  Usage: {% for prop in requiredProps(node.properties) %}
-#}
-{% macro requiredProps(properties) %}
-{%- for prop in properties %}{% if not prop.isOptional %}{{ prop | dump }},{% endif %}{% endfor -%}
-{% endmacro %}
-
-{#
-  Get optional properties from a list.
-  Usage: {% for prop in optionalProps(node.properties) %}
-#}
-{% macro optionalProps(properties) %}
-{%- for prop in properties %}{% if prop.isOptional %}{{ prop | dump }},{% endif %}{% endfor -%}
-{% endmacro %}
-
-{#
-  Get collection (array/list) properties that are complex types.
-  Usage: {% for prop in collectionProps(node.properties) %}
-#}
-{% macro collectionProps(properties) %}
-{%- for prop in properties %}{% if prop.isCollection and not prop.isScalar and not prop.isDict %}{{ prop | dump }},{% endif %}{% endfor -%}
-{% endmacro %}
-
-{#
-  Get scalar properties only.
-  Usage: {% for prop in scalarProps(node.properties) %}
-#}
-{% macro scalarProps(properties) %}
-{%- for prop in properties %}{% if prop.isScalar %}{{ prop | dump }},{% endif %}{% endfor -%}
-{% endmacro %}
-
-{#
-  Get complex (non-scalar) properties.
-  Usage: {% for prop in complexProps(node.properties) %}
-#}
-{% macro complexProps(properties) %}
-{%- for prop in properties %}{% if not prop.isScalar and not prop.isDict %}{{ prop | dump }},{% endif %}{% endfor -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Comment/Documentation Helpers
-   ============================================================================ #}
-
-{#
-  Wrap text as single-line comment.
-  Usage: {{ comment("This is a comment", "# ") }}
-#}
-{% macro comment(text, prefix) %}
-{%- if text %}{{ prefix }}{{ text }}{% endif -%}
-{% endmacro %}
-
-{#
-  Wrap multiline text as block comment.
-  Usage: {{ blockComment(description, "# ") }}
-#}
-{% macro blockComment(text, prefix) %}
-{%- if text -%}
-{%- for line in text.split('\n') %}
-{{ prefix }}{{ line }}
-{%- endfor -%}
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Validation/Test Helpers
-   ============================================================================ #}
-
-{#
-  Render a validation assertion based on value type.
-  This is a helper for test generation - language templates should customize.
-
-  Usage: {{ validationValue(value, delimeter) }}
-#}
-{% macro validationValue(value, delimeter) %}
-{%- if delimeter %}{{ delimeter }}{{ value }}{{ delimeter }}{% else %}{{ value }}{% endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   String Transformation Helpers
-   ============================================================================ #}
-
-{#
-  Convert to lowercase.
-  Usage: {{ lower("Hello") }} -> "hello"
-#}
-{% macro lower(text) %}{{ text | lower }}{% endmacro %}
-
-{#
-  Convert to uppercase.
-  Usage: {{ upper("Hello") }} -> "HELLO"
-#}
-{% macro upper(text) %}{{ text | upper }}{% endmacro %}
-
-{#
-  Join array with separator.
-  Usage: {{ joinArray(items, ", ") }}
-#}
-{% macro joinArray(items, separator) %}{{ items | join(separator) }}{% endmacro %}
-
-
-{# ============================================================================
-   Conditional Helpers
-   ============================================================================ #}
-
-{#
-  Render content only if value is truthy.
-  Usage: {% call ifTruthy(prop.description) %}{{ prop.description }}{% endcall %}
-#}
-{% macro ifTruthy(value) %}
-{%- if value %}{{ caller() }}{% endif -%}
-{% endmacro %}
-
-{#
-  Render first value if truthy, otherwise second.
-  Usage: {{ firstOrDefault(prop.defaultValue, "None") }}
-#}
-{% macro firstOrDefault(value, defaultValue) %}
-{%- if value %}{{ value }}{% else %}{{ defaultValue }}{% endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   File Header Rendering
-   ============================================================================ #}
-
-{#
-  Render a file header comment (optional, for documentation purposes).
-  Usage: {{ fileHeader("LoadContext") }}
-#}
-{% macro fileHeader(title) %}
-{%- if title -%}
-# {{ title }}
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Loop Helpers
-   ============================================================================ #}
-
-{#
-  Render separator between items (not after last).
-  Usage: {% for item in items %}{{ item }}{{ separator(loop, ", ") }}{% endfor %}
-#}
-{% macro separator(loop, sep) %}
-{%- if not loop.last %}{{ sep }}{% endif -%}
-{% endmacro %}
diff --git a/schema/emitter/src/templates/csharp/_macros.njk b/schema/emitter/src/templates/csharp/_macros.njk
deleted file mode 100644
index 69714856..00000000
--- a/schema/emitter/src/templates/csharp/_macros.njk
+++ /dev/null
@@ -1,162 +0,0 @@
-{#
-  C#-Specific Macros for AgentSchema Emitter
-  ==========================================
-
-  These macros handle C#-specific rendering logic, making templates
-  self-contained and easier to debug.
-
-  Usage in C# templates:
-    {% import "_macros.njk" as cs %}
-    {{ cs.csharpType(prop, typeMapper) }}
-#}
-
-{# ============================================================================
-   Type Rendering
-   ============================================================================ #}
-
-{#
-  Convert a property to its C# type.
-
-  @param prop - PropertyNode with type information
-  @param typeMapper - Record<string, string> mapping TypeSpec types to C# types
-#}
-{% macro csharpType(prop, typeMapper) %}
-{%- set baseType = typeMapper[prop.typeName.name] if prop.isScalar else prop.typeName.name -%}
-{%- if not baseType %}{% set baseType = "object" %}{% endif -%}
-{%- if prop.isDict -%}
-IDictionary<string, object?>
-{%- elif prop.isCollection -%}
-IList<{{ baseType }}>
-{%- else -%}
-{{ baseType }}
-{%- endif -%}
-{%- if prop.isOptional %}?{% endif -%}
-{% endmacro %}
-
-{#
-  Render C# type without optional marker (for generics, casts, etc.)
-#}
-{% macro csharpTypeNoOptional(prop, typeMapper) %}
-{%- set baseType = typeMapper[prop.typeName.name] if prop.isScalar else prop.typeName.name -%}
-{%- if not baseType %}{% set baseType = "object" %}{% endif -%}
-{%- if prop.isDict -%}
-IDictionary<string, object?>
-{%- elif prop.isCollection -%}
-IList<{{ baseType }}>
-{%- else -%}
-{{ baseType }}
-{%- endif -%}
-{% endmacro %}
-
-{# ============================================================================
-   Property Name Rendering
-   ============================================================================ #}
-
-{#
-  Convert property name to PascalCase for C#.
-
-  @param name - The property name (snake_case or camelCase)
-#}
-{% macro pascalCase(name) %}
-{%- set result = name | replace(r/_([a-z])/g, '$1' | upper) -%}
-{{ result[0] | upper }}{{ result | slice(1) }}
-{%- endmacro %}
-
-{# ============================================================================
-   Default Value Rendering
-   ============================================================================ #}
-
-{#
-  Render the default value for a C# property.
-
-  @param prop - PropertyNode with type and default value information
-  @param typeMapper - Type mapper
-#}
-{% macro defaultValue(prop, typeMapper) %}
-{%- if prop.isCollection %} = []
-{%- elif prop.isOptional %}
-{%- elif prop.isScalar -%}
-{%- if prop.typeName.name == "string" %} = "{{ prop.defaultValue if prop.defaultValue else "" }}"
-{%- elif prop.typeName.name == "boolean" %} = {{ "true" if prop.defaultValue else "false" }}
-{%- elif prop.typeName.name == "number" or prop.typeName.name == "float32" or prop.typeName.name == "float64" %} = {{ prop.defaultValue if prop.defaultValue else "0" }}
-{%- elif prop.typeName.name == "integer" or prop.typeName.name == "int32" or prop.typeName.name == "int64" %} = {{ prop.defaultValue if prop.defaultValue else "0" }}
-{%- elif prop.typeName.name == "dictionary" %} = new Dictionary<string, object?>()
-{%- endif -%}
-{%- endif -%}
-{% endmacro %}
-
-{# ============================================================================
-   Load Method Helpers
-   ============================================================================ #}
-
-{#
-  Render property assignment in Load() method.
-
-  @param prop - PropertyNode being assigned
-  @param varName - Variable name to assign to (e.g., "instance")
-  @param dictName - Dict variable name to read from (e.g., "data")
-  @param parentTypeName - Name of the parent type
-  @param typeMapper - Type mapper
-#}
-{% macro loadProperty(prop, varName, dictName, parentTypeName, typeMapper) %}
-{%- set propName = prop.name[0] | upper + prop.name | slice(1) -%}
-{%- set baseType = typeMapper[prop.typeName.name] if prop.isScalar else prop.typeName.name -%}
-{%- if prop.isScalar or prop.isDict -%}
-{{ varName }}.{{ propName }} = {{ dictName }}.GetValue<{{ baseType }}{% if prop.isOptional %}?{% endif %}>("{{ prop.name }}");
-{%- elif prop.isCollection -%}
-{{ varName }}.{{ propName }} = {{ parentTypeName }}.Load{{ propName }}({{ dictName }}["{{ prop.name }}"], context);
-{%- else -%}
-{{ varName }}.{{ propName }} = {{ prop.typeName.name }}.Load({{ dictName }}.GetDictionary("{{ prop.name }}"), context);
-{%- endif -%}
-{% endmacro %}
-
-{# ============================================================================
-   Save Method Helpers
-   ============================================================================ #}
-
-{#
-  Render property serialization in Save() method.
-
-  @param prop - PropertyNode being serialized
-  @param varName - Variable name of the object (e.g., "obj")
-  @param dictName - Dict variable name to write to (e.g., "result")
-  @param parentTypeName - Name of the parent type
-#}
-{% macro saveProperty(prop, varName, dictName, parentTypeName) %}
-{%- set propName = prop.name[0] | upper + prop.name | slice(1) -%}
-{%- if prop.isScalar or prop.isDict -%}
-{{ dictName }}["{{ prop.name }}"] = {{ varName }}.{{ propName }};
-{%- elif prop.isCollection -%}
-{{ dictName }}["{{ prop.name }}"] = {{ parentTypeName }}.Save{{ propName }}({{ varName }}.{{ propName }}, context);
-{%- else -%}
-{{ dictName }}["{{ prop.name }}"] = {{ varName }}.{{ propName }}.Save(context);
-{%- endif -%}
-{% endmacro %}
-
-{# ============================================================================
-   Summary/Documentation Helpers
-   ============================================================================ #}
-
-{#
-  Render XML summary comment for a property.
-
-  @param prop - PropertyNode with description
-#}
-{% macro summary(prop) %}
-/// <summary>
-/// {{ prop.description }}
-/// </summary>
-{% endmacro %}
-
-{#
-  Render XML summary comment for a class.
-
-  @param description - Class description
-#}
-{% macro classSummary(description) %}
-/// <summary>
-{%- for line in description.split('\n') %}
-/// {{ line }}
-{%- endfor %}
-/// </summary>
-{% endmacro %}
diff --git a/schema/emitter/src/templates/csharp/context.cs.njk b/schema/emitter/src/templates/csharp/context.cs.njk
deleted file mode 100644
index c4ed8739..00000000
--- a/schema/emitter/src/templates/csharp/context.cs.njk
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-using System.Text.Json;
-using YamlDotNet.Serialization;
-
-#pragma warning disable IDE0130
-namespace {{ namespace }};
-#pragma warning restore IDE0130
-
-/// <summary>
-/// Context for customizing the loading process of agent definitions.
-/// Provides hooks for pre-processing input data before parsing and
-/// post-processing output data after instantiation.
-/// </summary>
-public class LoadContext
-{
-    /// <summary>
-    /// Optional callback to transform input data before parsing.
-    /// </summary>
-    public Func<Dictionary<string, object?>, Dictionary<string, object?>>? PreProcess { get; set; }
-
-    /// <summary>
-    /// Optional callback to transform the result after instantiation.
-    /// </summary>
-    public Func<object, object>? PostProcess { get; set; }
-
-    /// <summary>
-    /// Apply pre-processing to input data if a PreProcess callback is set.
-    /// </summary>
-    /// <param name="data">The raw input dictionary to process.</param>
-    /// <returns>The processed dictionary, or the original if no callback is set.</returns>
-    public Dictionary<string, object?> ProcessInput(Dictionary<string, object?> data)
-    {
-        if (PreProcess is not null)
-        {
-            return PreProcess(data);
-        }
-        return data;
-    }
-
-    /// <summary>
-    /// Apply post-processing to the result if a PostProcess callback is set.
-    /// </summary>
-    /// <typeparam name="T">The type of the result.</typeparam>
-    /// <param name="result">The instantiated object to process.</param>
-    /// <returns>The processed result, or the original if no callback is set.</returns>
-    public T ProcessOutput<T>(T result) where T : class
-    {
-        if (PostProcess is not null)
-        {
-            return (T)PostProcess(result);
-        }
-        return result;
-    }
-}
-
-/// <summary>
-/// Context for customizing the serialization process of agent definitions.
-/// Provides hooks for pre-processing the object before serialization and
-/// post-processing the dictionary after serialization.
-/// </summary>
-public class SaveContext
-{
-    /// <summary>
-    /// Optional callback to transform the object before serialization.
-    /// </summary>
-    public Func<object, object>? PreSave { get; set; }
-
-    /// <summary>
-    /// Optional callback to transform the dictionary after serialization.
-    /// </summary>
-    public Func<Dictionary<string, object?>, Dictionary<string, object?>>? PostSave { get; set; }
-
-    /// <summary>
-    /// Output format for collections: "object" (name as key) or "array" (list of dicts).
-    /// Defaults to "object".
-    /// </summary>
-    public string CollectionFormat { get; set; } = "object";
-
-    /// <summary>
-    /// Use shorthand scalar representation when possible (e.g., {"myTool": "function"}).
-    /// Defaults to true.
-    /// </summary>
-    public bool UseShorthand { get; set; } = true;
-
-    /// <summary>
-    /// Apply pre-processing to the object if a PreSave callback is set.
-    /// </summary>
-    /// <typeparam name="T">The type of the object.</typeparam>
-    /// <param name="obj">The object to process before serialization.</param>
-    /// <returns>The processed object, or the original if no callback is set.</returns>
-    public T ProcessObject<T>(T obj) where T : class
-    {
-        if (PreSave is not null)
-        {
-            return (T)PreSave(obj);
-        }
-        return obj;
-    }
-
-    /// <summary>
-    /// Apply post-processing to the dictionary if a PostSave callback is set.
-    /// </summary>
-    /// <param name="data">The serialized dictionary to process.</param>
-    /// <returns>The processed dictionary, or the original if no callback is set.</returns>
-    public Dictionary<string, object?> ProcessDict(Dictionary<string, object?> data)
-    {
-        if (PostSave is not null)
-        {
-            return PostSave(data);
-        }
-        return data;
-    }
-
-    private static readonly JsonSerializerOptions s_jsonOptions = new()
-    {
-        WriteIndented = true,
-        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-    };
-
-    private static readonly ISerializer s_yamlSerializer = new SerializerBuilder()
-        .ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull)
-        .Build();
-
-    /// <summary>
-    /// Convert the dictionary to a YAML string.
-    /// </summary>
-    /// <param name="data">The dictionary to convert.</param>
-    /// <returns>The YAML string representation.</returns>
-    public string ToYaml(Dictionary<string, object?> data)
-    {
-        return s_yamlSerializer.Serialize(data);
-    }
-
-    /// <summary>
-    /// Convert the dictionary to a JSON string.
-    /// </summary>
-    /// <param name="data">The dictionary to convert.</param>
-    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
-    /// <returns>The JSON string representation.</returns>
-    public string ToJson(Dictionary<string, object?> data, bool indent = true)
-    {
-        var options = indent ? s_jsonOptions : new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
-        return JsonSerializer.Serialize(data, options);
-    }
-}
diff --git a/schema/emitter/src/templates/csharp/file.cs.njk b/schema/emitter/src/templates/csharp/file.cs.njk
deleted file mode 100644
index 1fdcc3b9..00000000
--- a/schema/emitter/src/templates/csharp/file.cs.njk
+++ /dev/null
@@ -1,462 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-using System.Text.Json;
-using YamlDotNet.Serialization;
-
-#pragma warning disable IDE0130
-namespace {{ namespace }};
-#pragma warning restore IDE0130
-
-/// <summary>
-{%- for line in node.description.split('\n') %}
-/// {{ line }}
-{%- endfor %}
-/// </summary>
-public{% if node.isAbstract %} abstract{% endif %} class {{ node.typeName.name }}{% if node.base %} : {{ node.base.name }}{% endif %}
-{
-    /// <summary>
-    /// The shorthand property name for this type, if any.
-    /// </summary>
-    public {% if node.base %}new {% endif %}static string? ShorthandProperty => {% if shorthandProperty %}"{{ shorthandProperty }}"{% else %}null{% endif %};
-
-    /// <summary>
-    /// Initializes a new instance of <see cref="{{ node.typeName.name }}"/>.
-    /// </summary>
-    #pragma warning disable CS8618
-    {% if node.isAbstract %}protected{% else %}public{% endif %} {{ node.typeName.name }}()
-    {
-    }
-    #pragma warning restore CS8618
-    {% for prop in node.properties %}
-    {{ renderSummary(prop) | safe }}
-    public {{ renderPropertyModifier(prop) }}{{ renderType(prop) | safe }} {{ renderPropertyName(prop) }} { get; set; }{{ renderDefault(prop) | safe }}
-    {% endfor %}
-
-    #region Load Methods
-
-    /// <summary>
-    /// Load a {{ node.typeName.name }} instance from a dictionary.
-    /// </summary>
-    /// <param name="data">The dictionary containing the data.</param>
-    /// <param name="context">Optional context with pre/post processing callbacks.</param>
-    /// <returns>The loaded {{ node.typeName.name }} instance.</returns>
-    public {% if node.base %}new {% endif %}static {{ node.typeName.name }} Load(Dictionary<string, object?> data, LoadContext? context = null)
-    {
-        if (context is not null)
-        {
-            data = context.ProcessInput(data);
-        }
-        {% if alternates.length > 0 %}
-        // Note: Alternate (shorthand) representations are handled by the converter
-        {% endif %}
-        {% if polymorphicTypes %}
-        // Load polymorphic {{ node.typeName.name }} instance
-        var instance = Load{{ renderPropertyName({ name: node.discriminator }) }}(data, context);
-        {% else %}
-        // Create new instance
-        var instance = new {{ node.typeName.name }}();
-        {% endif %}
-        {% for prop in node.properties %}
-        if (data.TryGetValue("{{ prop.name }}", out var {{ prop.name }}Value) && {{ prop.name }}Value is not null)
-        {
-            {{ renderLoadProperty(prop) | safe }}
-        }
-        {% endfor %}
-        if (context is not null)
-        {
-            instance = context.ProcessOutput(instance);
-        }
-        return instance;
-    }
-    {% for collection in collectionTypes %}
-
-    /// <summary>
-    /// Load a list of {{ collection.prop.typeName.name }} from a dictionary or list.
-    /// </summary>
-    public static IList<{{ collection.prop.typeName.name }}> Load{{ renderPropertyName(collection.prop) }}(object data, LoadContext? context)
-    {
-        var result = new List<{{ collection.prop.typeName.name }}>();
-
-        if (data is Dictionary<string, object?> dict)
-        {
-            // Convert named dictionary to list
-            foreach (var kvp in dict)
-            {
-                if (kvp.Value is IEnumerable<object>)
-                {
-                    throw new ArgumentException(
-                        $"Invalid '{{ collection.prop.name }}' format: key '{kvp.Key}' has an array value. " +
-                        $"'{{ collection.prop.name }}' must be a flat list of objects or a name-keyed dict — " +
-                        "not a nested {" + kvp.Key + ": [...]} structure.");
-                }
-                var itemDict = kvp.Value.GetDictionary();
-                if (itemDict.Count > 0)
-                {
-                    // Value is an object, add name to it
-                    itemDict["name"] = kvp.Key;
-                    result.Add({{ collection.prop.typeName.name }}.Load(itemDict, context));
-                }
-                else
-                {
-                    // Value is a scalar, use it as the primary property
-                    var newDict = new Dictionary<string, object?>
-                    {
-                        ["name"] = kvp.Key,
-                        ["{{ collection.type[0] }}"] = kvp.Value
-                    };
-                    result.Add({{ collection.prop.typeName.name }}.Load(newDict, context));
-                }
-            }
-        }
-        else if (data is IEnumerable<object> list)
-        {
-            foreach (var item in list)
-            {
-                var itemDict = item.GetDictionary({{ collection.prop.typeName.name }}.ShorthandProperty);
-                if (itemDict.Count > 0)
-                {
-                    result.Add({{ collection.prop.typeName.name }}.Load(itemDict, context));
-                }
-            }
-        }
-
-        return result;
-    }
-    {% endfor %}
-    {% if polymorphicTypes %}
-
-    /// <summary>
-    /// Load polymorphic {{ node.typeName.name }} based on discriminator.
-    /// </summary>
-    private static {{ node.typeName.name }} Load{{ renderPropertyName({ name: node.discriminator }) }}(Dictionary<string, object?> data, LoadContext? context)
-    {
-        if (data.TryGetValue("{{ node.discriminator }}", out var discriminatorValue) && discriminatorValue is not null)
-        {
-            var discriminator = discriminatorValue.ToString()?.ToLowerInvariant();
-            return discriminator switch
-            {
-                {%- for type in polymorphicTypes.types %}
-                "{{ type.value }}" => {{ type.instance.typeName.name }}.Load(data, context),
-                {%- endfor %}
-                {%- if polymorphicTypes.default %}
-                {%- if polymorphicTypes.default.instance.typeName.name == node.typeName.name %}
-                _ => new {{ node.typeName.name }}(),
-                {%- else %}
-                _ => {{ polymorphicTypes.default.instance.typeName.name }}.Load(data, context),
-                {%- endif %}
-                {%- else %}
-                _ => throw new ArgumentException($"Unknown {{ node.typeName.name }} discriminator value: {discriminator}"),
-                {%- endif %}
-            };
-        }
-        {% if node.isAbstract %}
-        throw new ArgumentException("Missing {{ node.typeName.name }} discriminator property: '{{ node.discriminator }}'");
-        {% else %}
-        return new {{ node.typeName.name }}();
-        {% endif %}
-    }
-    {% endif %}
-
-    #endregion
-
-    #region Save Methods
-
-    /// <summary>
-    /// Save the {{ node.typeName.name }} instance to a dictionary.
-    /// </summary>
-    /// <param name="context">Optional context with pre/post processing callbacks.</param>
-    /// <returns>The dictionary representation of this instance.</returns>
-    public {% if node.base %}override {% elif node.childTypes.length > 0 %}virtual {% endif %}Dictionary<string, object?> Save(SaveContext? context = null)
-    {
-        var obj = this;
-        if (context is not null)
-        {
-            obj = context.ProcessObject(obj);
-        }
-
-        {% if node.base %}
-        // Start with parent class properties
-        var result = base.Save(context);
-        {% else %}
-        var result = new Dictionary<string, object?>();
-        {% endif %}
-        {% for prop in node.properties %}
-        if (obj.{{ renderPropertyName(prop) }} is not null)
-        {
-            {{ renderSaveProperty(prop) | safe }}
-        }
-        {% endfor %}
-        {% if not node.base %}
-        if (context is not null)
-        {
-            result = context.ProcessDict(result);
-        }
-        {% endif %}
-        return result;
-    }
-    {% for collection in collectionTypes %}
-
-    /// <summary>
-    /// Save a list of {{ collection.prop.typeName.name }} to object or array format.
-    /// </summary>
-    public static object Save{{ renderPropertyName(collection.prop) }}(IList<{{ collection.prop.typeName.name }}> items, SaveContext? context)
-    {
-        context ??= new SaveContext();
-        {% if collection.hasNameProperty %}
-
-        if (context.CollectionFormat == "array")
-        {
-            return items.Select(item => item.Save(context)).ToList();
-        }
-
-        // Object format: use name as key
-        var result = new Dictionary<string, object?>();
-        foreach (var item in items)
-        {
-            var itemData = item.Save(context);
-            if (itemData.TryGetValue("name", out var nameValue) && nameValue is string name)
-            {
-                itemData.Remove("name");
-
-                // Check if we can use shorthand
-                if (context.UseShorthand && {{ collection.prop.typeName.name }}.ShorthandProperty is string shorthandProp)
-                {
-                    if (itemData.Count == 1 && itemData.ContainsKey(shorthandProp))
-                    {
-                        result[name] = itemData[shorthandProp];
-                        continue;
-                    }
-                }
-                result[name] = itemData;
-            }
-            else
-            {
-                // No name, can't use object format for this item
-                throw new InvalidOperationException("Cannot save item in object format: missing 'name' property");
-            }
-        }
-        return result;
-        {% else %}
-        // This collection type does not have a 'name' property, only array format is supported
-        return items.Select(item => item.Save(context)).ToList();
-        {% endif %}
-    }
-    {% endfor %}
-
-    /// <summary>
-    /// Convert the {{ node.typeName.name }} instance to a YAML string.
-    /// </summary>
-    /// <param name="context">Optional context with pre/post processing callbacks.</param>
-    /// <returns>The YAML string representation of this instance.</returns>
-    public {% if node.base %}new {% endif %}string ToYaml(SaveContext? context = null)
-    {
-        context ??= new SaveContext();
-        return context.ToYaml(Save(context));
-    }
-
-    /// <summary>
-    /// Convert the {{ node.typeName.name }} instance to a JSON string.
-    /// </summary>
-    /// <param name="context">Optional context with pre/post processing callbacks.</param>
-    /// <param name="indent">Whether to indent the output. Defaults to true.</param>
-    /// <returns>The JSON string representation of this instance.</returns>
-    public {% if node.base %}new {% endif %}string ToJson(SaveContext? context = null, bool indent = true)
-    {
-        context ??= new SaveContext();
-        return context.ToJson(Save(context), indent);
-    }
-
-    /// <summary>
-    /// Load a {{ node.typeName.name }} instance from a JSON string.
-    /// </summary>
-    /// <param name="json">The JSON string to parse.</param>
-    /// <param name="context">Optional context with pre/post processing callbacks.</param>
-    /// <returns>The loaded {{ node.typeName.name }} instance.</returns>
-    public {% if node.base %}new {% endif %}static {{ node.typeName.name }} FromJson(string json, LoadContext? context = null)
-    {
-        using var doc = JsonDocument.Parse(json);
-        Dictionary<string, object?> dict;
-
-        {%- if alternates.length > 0 or numericAlternates.length > 0 %}
-        // Handle alternate representations
-        if (doc.RootElement.ValueKind != JsonValueKind.Object)
-        {
-            var value = JsonUtils.GetJsonElementValue(doc.RootElement);
-            dict = value switch
-            {
-                {%- for alt in alternates %}
-                {{ alt.scalar }} {{ alt.scalar | lower }}Value => new Dictionary<string, object?>
-                {
-                    {%- for item in alt.expansion %}
-                    ["{{ item.property | lower | replace(".", "") }}"] = {{ item.value | safe }},
-                    {%- endfor %}
-                },
-                {%- endfor %}
-                {%- for alt in numericAlternates %}
-                {{ alt.scalar }} {{ alt.scalar | lower }}Value => new Dictionary<string, object?>
-                {
-                    {%- for item in alt.expansion %}
-                    ["{{ item.property | lower | replace(".", "") }}"] = {{ item.value | safe }},
-                    {%- endfor %}
-                },
-                {%- endfor %}
-                {%- if intAlternate %}
-                long longValue => new Dictionary<string, object?>
-                {
-                    {%- for item in intAlternate.expansion %}
-                    ["{{ item.property | lower | replace(".", "") }}"] = {% if "Value" in item.value %}longValue{% else %}{{ item.value | safe }}{% endif %},
-                    {%- endfor %}
-                },
-                {%- endif %}
-                {%- if floatAlternate %}
-                double doubleValue => new Dictionary<string, object?>
-                {
-                    {%- for item in floatAlternate.expansion %}
-                    ["{{ item.property | lower | replace(".", "") }}"] = {% if "Value" in item.value %}doubleValue{% else %}{{ item.value | safe }}{% endif %},
-                    {%- endfor %}
-                },
-                {%- endif %}
-                {%- if shorthandProperty %}
-                _ => new Dictionary<string, object?>
-                {
-                    ["{{ shorthandProperty }}"] = value
-                }
-                {%- else %}
-                _ => throw new ArgumentException($"Cannot convert value of type {value?.GetType().Name} to {{ node.typeName.name }}")
-                {%- endif %}
-            };
-        }
-        else
-        {
-            dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
-                ?? throw new ArgumentException("Failed to parse JSON as dictionary");
-        }
-        {%- elif shorthandProperty %}
-        // Handle shorthand representation
-        if (doc.RootElement.ValueKind != JsonValueKind.Object)
-        {
-            dict = new Dictionary<string, object?>
-            {
-                ["{{ shorthandProperty }}"] = JsonUtils.GetJsonElementValue(doc.RootElement)
-            };
-        }
-        else
-        {
-            dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
-                ?? throw new ArgumentException("Failed to parse JSON as dictionary");
-        }
-        {%- else %}
-        dict = JsonSerializer.Deserialize<Dictionary<string, object?>>(json, JsonUtils.Options)
-            ?? throw new ArgumentException("Failed to parse JSON as dictionary");
-        {%- endif %}
-
-        return Load(dict, context);
-    }
-
-    /// <summary>
-    /// Load a {{ node.typeName.name }} instance from a YAML string.
-    /// </summary>
-    /// <param name="yaml">The YAML string to parse.</param>
-    /// <param name="context">Optional context with pre/post processing callbacks.</param>
-    /// <returns>The loaded {{ node.typeName.name }} instance.</returns>
-    public {% if node.base %}new {% endif %}static {{ node.typeName.name }} FromYaml(string yaml, LoadContext? context = null)
-    {
-        {%- if alternates.length > 0 or numericAlternates.length > 0 %}
-        // Handle alternate representations - try object first, fall back to scalar
-        Dictionary<string, object?>? dictResult = null;
-        try
-        {
-            dictResult = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml);
-        }
-        catch (YamlDotNet.Core.YamlException)
-        {
-            // Not a dictionary, will be handled as scalar below
-        }
-
-        Dictionary<string, object?> dict;
-        if (dictResult is not null)
-        {
-            dict = dictResult;
-        }
-        else
-        {
-            // Parse as scalar with proper type inference
-            var parsed = YamlUtils.ParseScalar(yaml);
-            dict = parsed switch
-            {
-                {%- for alt in alternates %}
-                {{ alt.scalar }} {{ alt.scalar | lower }}Value => new Dictionary<string, object?>
-                {
-                    {%- for item in alt.expansion %}
-                    ["{{ item.property | lower | replace(".", "") }}"] = {{ item.value | safe }},
-                    {%- endfor %}
-                },
-                {%- endfor %}
-                {%- for alt in numericAlternates %}
-                {{ alt.scalar }} {{ alt.scalar | lower }}Value => new Dictionary<string, object?>
-                {
-                    {%- for item in alt.expansion %}
-                    ["{{ item.property | lower | replace(".", "") }}"] = {{ item.value | safe }},
-                    {%- endfor %}
-                },
-                {%- endfor %}
-                {%- if intAlternate %}
-                long longValue => new Dictionary<string, object?>
-                {
-                    {%- for item in intAlternate.expansion %}
-                    ["{{ item.property | lower | replace(".", "") }}"] = {% if "Value" in item.value %}longValue{% else %}{{ item.value | safe }}{% endif %},
-                    {%- endfor %}
-                },
-                {%- endif %}
-                {%- if floatAlternate %}
-                double doubleValue => new Dictionary<string, object?>
-                {
-                    {%- for item in floatAlternate.expansion %}
-                    ["{{ item.property | lower | replace(".", "") }}"] = {% if "Value" in item.value %}doubleValue{% else %}{{ item.value | safe }}{% endif %},
-                    {%- endfor %}
-                },
-                {%- endif %}
-                {%- if shorthandProperty %}
-                _ => new Dictionary<string, object?>
-                {
-                    ["{{ shorthandProperty }}"] = parsed
-                }
-                {%- else %}
-                _ => throw new ArgumentException($"Cannot convert value of type {parsed?.GetType().Name} to {{ node.typeName.name }}")
-                {%- endif %}
-            };
-        }
-        {%- elif shorthandProperty %}
-        // Handle shorthand representation - try object first, fall back to scalar
-        Dictionary<string, object?>? dictResult = null;
-        try
-        {
-            dictResult = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml);
-        }
-        catch (YamlDotNet.Core.YamlException)
-        {
-            // Not a dictionary, will be handled as scalar below
-        }
-
-        Dictionary<string, object?> dict;
-        if (dictResult is not null)
-        {
-            dict = dictResult;
-        }
-        else
-        {
-            // Shorthand representation - wrap the value with proper type inference
-            dict = new Dictionary<string, object?>
-            {
-                ["{{ shorthandProperty }}"] = YamlUtils.ParseScalar(yaml)
-            };
-        }
-        {%- else %}
-        var dict = YamlUtils.Deserializer.Deserialize<Dictionary<string, object?>>(yaml)
-            ?? throw new ArgumentException("Failed to parse YAML as dictionary");
-        {%- endif %}
-
-        return Load(dict, context);
-    }
-
-    #endregion
-}
diff --git a/schema/emitter/src/templates/csharp/test.cs.njk b/schema/emitter/src/templates/csharp/test.cs.njk
deleted file mode 100644
index b7570a32..00000000
--- a/schema/emitter/src/templates/csharp/test.cs.njk
+++ /dev/null
@@ -1,218 +0,0 @@
-{#
-  C# Test Template
-  ================
-  Renders C# xUnit test file for a type.
-
-  Expected context:
-    - node: TypeNode
-    - namespace: string
-    - examples: Array<{ json: string[], yaml: string[], validations: Array<{ key, value, startDelim, endDelim }> }>
-    - alternates: Array<{ title, scalar, value, validations: Array<{ key, value, delimiter }> }>
-#}
-using Xunit;
-
-#pragma warning disable IDE0130
-namespace {{ namespace }};
-#pragma warning restore IDE0130
-
-
-public class {{ node.typeName.name }}ConversionTests
-{
-{%- for sample in examples %}
-    [Fact]
-    public void LoadYamlInput{% if not loop.first %}{{loop.index - 1}}{% endif %}()
-    {
-        string yamlData = """
-{%- for line in sample.yaml %}
-{{ line | safe }}
-{%- endfor %}
-""";
-
-        var instance = {{ node.typeName.name }}.FromYaml(yamlData);
-
-        Assert.NotNull(instance);
-
-        {%- for validation in sample.validations %}
-        {%- if validation.value == "True" or validation.value == "False" %}
-        Assert.{% if validation.value == "False" %}False{% else %}True{% endif %}(instance.{{ validation.key  }});
-        {%- elif validation.startDelim == '@"' %}
-        Assert.Equal({{ validation.startDelim | safe }}{{ validation.value | safe }}{{ validation.endDelim | safe }}.Replace("\r\n", "\n"), instance.{{ validation.key }});
-        {%- else %}
-        Assert.Equal({{ validation.startDelim | safe }}{{ validation.value | safe }}{{ validation.endDelim | safe }}, instance.{{ validation.key }});
-        {%- endif %}
-        {%- endfor %}
-    }
-
-    [Fact]
-    public void LoadJsonInput{% if not loop.first %}{{loop.index - 1}}{% endif %}()
-    {
-        string jsonData = """
-{%- for line in sample.json %}
-{{ line | safe }}
-{%- endfor %}
-""";
-
-        var instance = {{ node.typeName.name }}.FromJson(jsonData);
-        Assert.NotNull(instance);
-        {%- for validation in sample.validations %}
-        {%- if validation.value == "True" or validation.value == "False" %}
-        Assert.{% if validation.value == "False" %}False{% else %}True{% endif %}(instance.{{ validation.key  }});
-        {%- elif validation.startDelim == '@"' %}
-        Assert.Equal({{ validation.startDelim | safe }}{{ validation.value | safe }}{{ validation.endDelim | safe }}.Replace("\r\n", "\n"), instance.{{ validation.key }});
-        {%- else %}
-        Assert.Equal({{ validation.startDelim | safe }}{{ validation.value | safe }}{{ validation.endDelim | safe }}, instance.{{ validation.key }});
-        {%- endif %}
-        {%- endfor %}
-    }
-
-    [Fact]
-    public void RoundtripJson{% if not loop.first %}{{loop.index - 1}}{% endif %}()
-    {
-        // Test that FromJson -> ToJson -> FromJson produces equivalent data
-        string jsonData = """
-{%- for line in sample.json %}
-{{ line | safe }}
-{%- endfor %}
-""";
-
-        var original = {{ node.typeName.name }}.FromJson(jsonData);
-        Assert.NotNull(original);
-
-        var json = original.ToJson();
-        Assert.False(string.IsNullOrEmpty(json));
-
-        var reloaded = {{ node.typeName.name }}.FromJson(json);
-        Assert.NotNull(reloaded);
-        {%- for validation in sample.validations %}
-        {%- if validation.value == "True" or validation.value == "False" %}
-        Assert.{% if validation.value == "False" %}False{% else %}True{% endif %}(reloaded.{{ validation.key  }});
-        {%- elif validation.startDelim == '@"' %}
-        Assert.Equal({{ validation.startDelim | safe }}{{ validation.value | safe }}{{ validation.endDelim | safe }}.Replace("\r\n", "\n"), reloaded.{{ validation.key }});
-        {%- else %}
-        Assert.Equal({{ validation.startDelim | safe }}{{ validation.value | safe }}{{ validation.endDelim | safe }}, reloaded.{{ validation.key }});
-        {%- endif %}
-        {%- endfor %}
-    }
-
-    [Fact]
-    public void RoundtripYaml{% if not loop.first %}{{loop.index - 1}}{% endif %}()
-    {
-        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data
-        string yamlData = """
-{%- for line in sample.yaml %}
-{{ line | safe }}
-{%- endfor %}
-""";
-
-        var original = {{ node.typeName.name }}.FromYaml(yamlData);
-        Assert.NotNull(original);
-
-        var yaml = original.ToYaml();
-        Assert.False(string.IsNullOrEmpty(yaml));
-
-        var reloaded = {{ node.typeName.name }}.FromYaml(yaml);
-        Assert.NotNull(reloaded);
-        {%- for validation in sample.validations %}
-        {%- if validation.value == "True" or validation.value == "False" %}
-        Assert.{% if validation.value == "False" %}False{% else %}True{% endif %}(reloaded.{{ validation.key  }});
-        {%- elif validation.startDelim == '@"' %}
-        Assert.Equal({{ validation.startDelim | safe }}{{ validation.value | safe }}{{ validation.endDelim | safe }}.Replace("\r\n", "\n"), reloaded.{{ validation.key }});
-        {%- else %}
-        Assert.Equal({{ validation.startDelim | safe }}{{ validation.value | safe }}{{ validation.endDelim | safe }}, reloaded.{{ validation.key }});
-        {%- endif %}
-        {%- endfor %}
-    }
-
-    [Fact]
-    public void ToJsonProducesValidJson{% if not loop.first %}{{loop.index - 1}}{% endif %}()
-    {
-        string jsonData = """
-{%- for line in sample.json %}
-{{ line | safe }}
-{%- endfor %}
-""";
-
-        var instance = {{ node.typeName.name }}.FromJson(jsonData);
-        var json = instance.ToJson();
-
-        // Verify it's valid JSON by parsing it
-        var parsed = System.Text.Json.JsonDocument.Parse(json);
-        Assert.NotNull(parsed);
-    }
-
-    [Fact]
-    public void ToYamlProducesValidYaml{% if not loop.first %}{{loop.index - 1}}{% endif %}()
-    {
-        string yamlData = """
-{%- for line in sample.yaml %}
-{{ line | safe }}
-{%- endfor %}
-""";
-
-        var instance = {{ node.typeName.name }}.FromYaml(yamlData);
-        var yaml = instance.ToYaml();
-
-        // Verify it's valid YAML by parsing it
-        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();
-        var parsed = deserializer.Deserialize<object>(yaml);
-        Assert.NotNull(parsed);
-    }
-    {%- endfor %}
-
-    {%- if alternates.length > 0 %}
-    {% for alt in alternates -%}
-    [Fact]
-    public void LoadJsonFrom{{ alt.scalar | title }}()
-    {
-        // alternate representation as {{ alt.scalar }}
-        {%- if alt.scalar == "string" %}
-        var data = "{{ alt.value | replace('"', '\\"') | safe }}";
-        {%- else %}
-        var data = "{% if alt.value == "True" %}true{% elif alt.value == "False" %}false{% else %}{{ alt.value | safe }}{% endif %}";
-        {%- endif %}
-        var instance = {{ node.typeName.name }}.FromJson(data);
-        Assert.NotNull(instance);
-        {%- for item in alt.validations %}
-        {%- if item.value == "True" or item.value == "False" %}
-        Assert.NotNull(instance.{{ item.key }});
-        Assert.IsType<bool>(instance.{{ item.key }});
-        Assert.{% if item.value == "False" %}False{% else %}True{% endif %}((bool)instance.{{ item.key }});
-        {%- elif item.value | isFloat %}
-        Assert.NotNull(instance.{{ item.key }});
-        Assert.True(instance.{{ item.key }} is float || instance.{{ item.key }} is double || instance.{{ item.key }} is int || instance.{{ item.key }} is long);
-        Assert.Equal({{ item.value | safe }}, Convert.ToDouble(instance.{{ item.key }}), 5);
-        {%- else %}
-        Assert.Equal({{ item.delimiter | safe }}{{ item.value | safe }}{{ item.delimiter | safe }}, instance.{{ item.key }});
-        {%- endif %}
-        {%- endfor %}
-    }
-
-    [Fact]
-    public void LoadYamlFrom{{ alt.scalar | title }}()
-    {
-        // alternate representation as {{ alt.scalar }}
-        {%- if alt.scalar == "string" %}
-        var data = "{{ alt.value | replace('"', '\\"') | safe }}";
-        {%- else %}
-        var data = "{% if alt.value == "True" %}true{% elif alt.value == "False" %}false{% else %}{{ alt.value | safe }}{% endif %}";
-        {%- endif %}
-        var instance = {{ node.typeName.name }}.FromYaml(data);
-        Assert.NotNull(instance);
-
-        {%- for item in alt.validations %}
-        {%- if item.value == "True" or item.value == "False" %}
-        Assert.NotNull(instance.{{ item.key }});
-        Assert.IsType<bool>(instance.{{ item.key }});
-        Assert.{% if item.value == "False" %}False{% else %}True{% endif %}((bool)instance.{{ item.key }});
-        {%- elif item.value | isFloat %}
-        Assert.NotNull(instance.{{ item.key }});
-        Assert.True(instance.{{ item.key }} is float || instance.{{ item.key }} is double || instance.{{ item.key }} is int || instance.{{ item.key }} is long);
-        Assert.Equal({{ item.value | safe }}, Convert.ToDouble(instance.{{ item.key }}), 5);
-        {%- else %}
-        Assert.Equal({{ item.delimiter | safe }}{{ item.value | safe }}{{ item.delimiter | safe }}, instance.{{ item.key }});
-        {%- endif %}
-        {%- endfor %}
-    }
-    {% endfor %}
-    {%- endif %}
-}
diff --git a/schema/emitter/src/templates/go/_macros.njk b/schema/emitter/src/templates/go/_macros.njk
deleted file mode 100644
index 507ca130..00000000
--- a/schema/emitter/src/templates/go/_macros.njk
+++ /dev/null
@@ -1,435 +0,0 @@
-{#
-  Go-Specific Macros for AgentSchema Emitter
-  ==========================================
-
-  These macros handle Go-specific rendering logic.
-
-  Usage in Go templates:
-    {% import "_macros.njk" as go %}
-    {{ go.goType(prop, typeMapper) }}
-#}
-
-{# Import shared macros #}
-{% from "macros.njk" import separator, firstOrDefault, validationValue %}
-
-
-{# ============================================================================
-   Comment Rendering
-   ============================================================================ #}
-
-{#
-  Format a multi-line description as Go comment lines.
-  Each line is prefixed with "// ".
-
-  @param text - Multi-line description text
-
-  Usage: {{ goComment("Some description") }}
-#}
-{% macro goComment(text) -%}
-{%- if text -%}
-{%- set lines = text.split('\n') -%}
-{%- for line in lines -%}
-// {{ line }}
-{% endfor -%}
-{%- endif -%}
-{%- endmacro %}
-
-
-{#
-  Escape a string value for use in Go code.
-  Handles quotes, backslashes, newlines, etc.
-
-  @param value - String value to escape
-  @param delimeter - Quote character (" or empty)
-
-  Usage: {{ goEscape(value, '"') }}
-#}
-{% macro goEscape(value, delimeter) -%}
-{%- if delimeter == "\"" -%}
-{{ value | replace("\\", "\\\\") | replace("\"", "\\\"") | replace("\n", "\\n") | replace("\r", "\\r") | replace("\t", "\\t") }}
-{%- else -%}
-{{ value }}
-{%- endif -%}
-{%- endmacro %}
-
-
-{# ============================================================================
-   Type Rendering
-   ============================================================================ #}
-
-{#
-  Convert a property to its Go type annotation.
-
-  Handles:
-  - Scalar types (string, int32, float64, bool, etc.)
-  - Collections ([]T)
-  - Pointers for optionals (*T)
-  - Maps (map[string]interface{})
-
-  @param prop - PropertyNode with type information
-  @param typeMapper - Record<string, string> mapping TypeSpec types to Go types
-
-  Usage: {{ goType(prop, typeMapper) }}
-#}
-{% macro goType(prop, typeMapper, polymorphicTypeNames) %}
-{%- set baseType = typeMapper[prop.typeName.name] if prop.isScalar else (typeMapper[prop.typeName.name] or prop.typeName.name) -%}
-{%- if not baseType %}{% set baseType = "interface{}" %}{% endif -%}
-{%- if prop.isDict -%}
-map[string]interface{}
-{%- elif prop.isCollection and prop.typeName.name in polymorphicTypeNames -%}
-[]interface{}
-{%- elif prop.isCollection -%}
-[]{{ baseType }}
-{%- elif not prop.isScalar and prop.typeName.name in polymorphicTypeNames -%}
-interface{}
-{%- elif prop.isOptional -%}
-*{{ baseType }}
-{%- else -%}
-{{ baseType }}
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Property Name Rendering
-   ============================================================================ #}
-
-{#
-  Render property name in PascalCase for exported fields.
-  Handles both snake_case and camelCase input.
-
-  @param name - Property name (may be camelCase or snake_case)
-
-  Usage: {{ propName(prop.name) }}
-#}
-{% macro propName(name) %}{{ name | pascalCase }}{% endmacro %}
-
-
-{# ============================================================================
-   JSON/YAML Tag Rendering
-   ============================================================================ #}
-
-{#
-  Render struct field tags for JSON and YAML serialization.
-
-  @param prop - PropertyNode with name and optional flag
-
-  Usage: {{ structTags(prop) }}
-#}
-{% macro structTags(prop) -%}
-`json:"{{ prop.name }}{% if prop.isOptional %},omitempty{% endif %}" yaml:"{{ prop.name }}{% if prop.isOptional %},omitempty{% endif %}"`
-{%- endmacro %}
-
-
-{# ============================================================================
-   Default Value Rendering
-   ============================================================================ #}
-
-{#
-  Render the default value initialization for a field.
-
-  @param prop - PropertyNode with type and default value information
-  @param typeMapper - Record<string, string> for type lookups
-
-  Usage: {{ defaultValue(prop, typeMapper) }}
-#}
-{% macro defaultValue(prop, typeMapper) -%}
-{%- if prop.isCollection -%}
-make([]{{ typeMapper[prop.typeName.name] if prop.isScalar else prop.typeName.name }}, 0)
-{%- elif prop.isDict -%}
-make(map[string]interface{})
-{%- elif prop.isOptional -%}
-nil
-{%- elif prop.isScalar -%}
-{%- if prop.typeName.name == "boolean" -%}
-{{ "true" if prop.defaultValue else "false" }}
-{%- elif prop.typeName.name == "string" -%}
-"{{ prop.defaultValue if prop.defaultValue else "" }}"
-{%- elif prop.typeName.name == "number" or prop.typeName.name == "integer" or prop.typeName.name == "int32" or prop.typeName.name == "int64" or prop.typeName.name == "float32" or prop.typeName.name == "float64" -%}
-{{ prop.defaultValue if prop.defaultValue else "0" }}
-{%- else -%}
-nil
-{%- endif -%}
-{%- else -%}
-nil
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Load Property Rendering
-   ============================================================================ #}
-
-{#
-  Render the property loading code from map[string]interface{}.
-
-  @param prop - PropertyNode
-  @param varName - Variable name containing the data
-  @param typeMapper - Type mapping dictionary
-  @param polymorphicTypeNames - Array of type names that are polymorphic (return interface{})
-
-  Usage: {{ loadProperty(prop, "data", typeMapper, polymorphicTypeNames) }}
-#}
-{% macro loadProperty(prop, varName, typeMapper, polymorphicTypeNames) -%}
-{%- set propNameGo = propName(prop.name) -%}
-{%- if prop.isCollection and not prop.isDict -%}
-{%- if prop.isScalar -%}
-{%- if prop.typeName.name == "unknown" or prop.typeName.name == "any" -%}
-		if val, ok := {{ varName }}["{{ prop.name }}"]; ok && val != nil {
-			if arr, ok := val.([]interface{}); ok {
-				result.{{ propNameGo }} = arr
-			}
-		}
-{%- else -%}
-		if val, ok := {{ varName }}["{{ prop.name }}"]; ok && val != nil {
-			if arr, ok := val.([]interface{}); ok {
-				result.{{ propNameGo }} = make([]{{ typeMapper[prop.typeName.name] }}, len(arr))
-				for i, v := range arr {
-					result.{{ propNameGo }}[i] = v.({{ typeMapper[prop.typeName.name] }})
-				}
-			}
-		}
-{%- endif -%}
-{%- else -%}
-		if val, ok := {{ varName }}["{{ prop.name }}"]; ok && val != nil {
-			if arr, ok := val.([]interface{}); ok {
-				{%- if prop.typeName.name in polymorphicTypeNames %}
-				result.{{ propNameGo }} = make([]interface{}, len(arr))
-				{%- else %}
-				result.{{ propNameGo }} = make([]{{ prop.typeName.name }}, len(arr))
-				{%- endif %}
-				for i, v := range arr {
-					if item, ok := v.(map[string]interface{}); ok {
-						loaded, _ := Load{{ prop.typeName.name }}(item, ctx)
-						{%- if prop.typeName.name in polymorphicTypeNames %}
-						// Polymorphic type - store as interface{}
-						result.{{ propNameGo }}[i] = loaded
-						{%- else %}
-						result.{{ propNameGo }}[i] = loaded
-						{%- endif %}
-					}
-				}
-			}
-		}
-{%- endif -%}
-{%- elif prop.isDict -%}
-		if val, ok := {{ varName }}["{{ prop.name }}"]; ok && val != nil {
-			if m, ok := val.(map[string]interface{}); ok {
-				result.{{ propNameGo }} = m
-			}
-		}
-{%- elif prop.isScalar -%}
-		if val, ok := {{ varName }}["{{ prop.name }}"]; ok && val != nil {
-{%- if prop.typeName.name == "unknown" or prop.typeName.name == "any" -%}
-{%- if prop.isOptional -%}
-			result.{{ propNameGo }} = &val
-{%- else -%}
-			result.{{ propNameGo }} = val
-{%- endif -%}
-{%- elif prop.typeName.name == "int32" or prop.typeName.name == "int64" or prop.typeName.name == "integer" -%}
-{%- if prop.isOptional -%}
-			// Handle various numeric types from JSON/YAML/roundtrip
-			var v {{ typeMapper[prop.typeName.name] or "int" }}
-			switch n := val.(type) {
-			case int:
-				v = {{ typeMapper[prop.typeName.name] or "int" }}(n)
-			case int32:
-				v = {{ typeMapper[prop.typeName.name] or "int" }}(n)
-			case int64:
-				v = {{ typeMapper[prop.typeName.name] or "int" }}(n)
-			case float64:
-				v = {{ typeMapper[prop.typeName.name] or "int" }}(n)
-			}
-			result.{{ propNameGo }} = &v
-{%- else -%}
-			// Handle various numeric types from JSON/YAML/roundtrip
-			switch n := val.(type) {
-			case int:
-				result.{{ propNameGo }} = {{ typeMapper[prop.typeName.name] or "int" }}(n)
-			case int32:
-				result.{{ propNameGo }} = {{ typeMapper[prop.typeName.name] or "int" }}(n)
-			case int64:
-				result.{{ propNameGo }} = {{ typeMapper[prop.typeName.name] or "int" }}(n)
-			case float64:
-				result.{{ propNameGo }} = {{ typeMapper[prop.typeName.name] or "int" }}(n)
-			}
-{%- endif -%}
-{%- elif prop.typeName.name == "float32" -%}
-{%- if prop.isOptional -%}
-			// Handle various numeric types from JSON/YAML/roundtrip
-			var v float32
-			switch n := val.(type) {
-			case int:
-				v = float32(n)
-			case int32:
-				v = float32(n)
-			case int64:
-				v = float32(n)
-			case float32:
-				v = n
-			case float64:
-				v = float32(n)
-			}
-			result.{{ propNameGo }} = &v
-{%- else -%}
-			// Handle various numeric types from JSON/YAML/roundtrip
-			switch n := val.(type) {
-			case int:
-				result.{{ propNameGo }} = float32(n)
-			case int32:
-				result.{{ propNameGo }} = float32(n)
-			case int64:
-				result.{{ propNameGo }} = float32(n)
-			case float32:
-				result.{{ propNameGo }} = n
-			case float64:
-				result.{{ propNameGo }} = float32(n)
-			}
-{%- endif -%}
-{%- elif prop.typeName.name == "float64" or prop.typeName.name == "number" or prop.typeName.name == "float" or prop.typeName.name == "numeric" -%}
-{%- if prop.isOptional -%}
-			// Handle various numeric types from JSON/YAML/roundtrip
-			var v float64
-			switch n := val.(type) {
-			case int:
-				v = float64(n)
-			case int32:
-				v = float64(n)
-			case int64:
-				v = float64(n)
-			case float32:
-				v = float64(n)
-			case float64:
-				v = n
-			}
-			result.{{ propNameGo }} = &v
-{%- else -%}
-			// Handle various numeric types from JSON/YAML/roundtrip
-			switch n := val.(type) {
-			case int:
-				result.{{ propNameGo }} = float64(n)
-			case int32:
-				result.{{ propNameGo }} = float64(n)
-			case int64:
-				result.{{ propNameGo }} = float64(n)
-			case float32:
-				result.{{ propNameGo }} = float64(n)
-			case float64:
-				result.{{ propNameGo }} = n
-			}
-{%- endif -%}
-{%- else -%}
-{%- if prop.isOptional -%}
-			v := val.({{ typeMapper[prop.typeName.name] or "interface{}" }})
-			result.{{ propNameGo }} = &v
-{%- else -%}
-			result.{{ propNameGo }} = val.({{ typeMapper[prop.typeName.name] or "interface{}" }})
-{%- endif -%}
-{%- endif -%}
-		}
-{%- else -%}
-		if val, ok := {{ varName }}["{{ prop.name }}"]; ok && val != nil {
-			if m, ok := val.(map[string]interface{}); ok {
-				loaded, _ := Load{{ prop.typeName.name }}(m, ctx)
-{%- if prop.isOptional %}
-				{%- if prop.typeName.name in polymorphicTypeNames %}
-				// Polymorphic type - keep as interface{} (no pointer needed, interface{} can be nil)
-				result.{{ propNameGo }} = loaded
-				{%- else %}
-				result.{{ propNameGo }} = &loaded
-				{%- endif %}
-{%- else %}
-				{%- if prop.typeName.name in polymorphicTypeNames %}
-				// Polymorphic type - keep as interface{}
-				result.{{ propNameGo }} = loaded
-				{%- else %}
-				result.{{ propNameGo }} = loaded
-				{%- endif %}
-{%- endif %}
-			}
-		}
-{%- endif -%}
-{%- endmacro %}
-
-
-{# ============================================================================
-   Save Property Rendering
-   ============================================================================ #}
-
-{#
-  Render the property saving code to map[string]interface{}.
-
-  @param prop - PropertyNode
-
-  Usage: {{ saveProperty(prop) }}
-#}
-{% macro saveProperty(prop, polymorphicTypeNames) -%}
-{%- set propNameGo = propName(prop.name) -%}
-{%- if prop.isCollection and not prop.isDict -%}
-{%- if prop.isScalar -%}
-	result["{{ prop.name }}"] = obj.{{ propNameGo }}
-{%- elif prop.typeName.name in polymorphicTypeNames -%}
-	if obj.{{ propNameGo }} != nil {
-		arr := make([]interface{}, len(obj.{{ propNameGo }}))
-		for i, item := range obj.{{ propNameGo }} {
-			// Handle polymorphic type via type switch
-			switch v := item.(type) {
-			case interface{ Save(*SaveContext) map[string]interface{} }:
-				arr[i] = v.Save(ctx)
-			default:
-				arr[i] = item
-			}
-		}
-		result["{{ prop.name }}"] = arr
-	}
-{%- else -%}
-	if obj.{{ propNameGo }} != nil {
-		arr := make([]interface{}, len(obj.{{ propNameGo }}))
-		for i, item := range obj.{{ propNameGo }} {
-			arr[i] = item.Save(ctx)
-		}
-		result["{{ prop.name }}"] = arr
-	}
-{%- endif -%}
-{%- elif prop.isDict -%}
-{%- if prop.isOptional -%}
-	if obj.{{ propNameGo }} != nil {
-		result["{{ prop.name }}"] = obj.{{ propNameGo }}
-	}
-{%- else -%}
-	result["{{ prop.name }}"] = obj.{{ propNameGo }}
-{%- endif -%}
-{%- elif prop.isScalar and not prop.isOptional -%}
-	result["{{ prop.name }}"] = obj.{{ propNameGo }}
-{%- elif prop.isOptional -%}
-	if obj.{{ propNameGo }} != nil {
-{%- if prop.isScalar -%}
-		result["{{ prop.name }}"] = *obj.{{ propNameGo }}
-{%- elif prop.typeName.name in polymorphicTypeNames %}
-	// Handle polymorphic type (stored as interface{} without pointer)
-	if obj.{{ propNameGo }} != nil {
-		switch v := obj.{{ propNameGo }}.(type) {
-		case interface{ Save(*SaveContext) map[string]interface{} }:
-			result["{{ prop.name }}"] = v.Save(ctx)
-		default:
-			result["{{ prop.name }}"] = obj.{{ propNameGo }}
-		}
-	}
-{%- else %}
-		result["{{ prop.name }}"] = obj.{{ propNameGo }}.Save(ctx)
-{%- endif -%}
-	}
-{%- else -%}
-	{%- if not prop.isScalar and prop.typeName.name in polymorphicTypeNames %}
-	// Handle polymorphic type via type switch
-	switch v := obj.{{ propNameGo }}.(type) {
-	case interface{ Save(*SaveContext) map[string]interface{} }:
-		result["{{ prop.name }}"] = v.Save(ctx)
-	default:
-		result["{{ prop.name }}"] = obj.{{ propNameGo }}
-	}
-	{%- else %}
-	result["{{ prop.name }}"] = obj.{{ propNameGo }}.Save(ctx)
-	{%- endif %}
-{%- endif -%}
-{%- endmacro %}
diff --git a/schema/emitter/src/templates/go/context.go.njk b/schema/emitter/src/templates/go/context.go.njk
deleted file mode 100644
index 9410302e..00000000
--- a/schema/emitter/src/templates/go/context.go.njk
+++ /dev/null
@@ -1,35 +0,0 @@
-{#
-  Go Context Template
-  ===================
-  Renders LoadContext and SaveContext utilities.
-
-  Expected context (GoContextContext):
-    - header: string
-    - packageName: string
-#}
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-// {{ header }}
-
-package {{ packageName }}
-
-// LoadContext provides context for loading operations
-type LoadContext struct {
-	// Add any context fields needed for loading
-	// e.g., file paths, base directories, etc.
-}
-
-// NewLoadContext creates a new LoadContext
-func NewLoadContext() *LoadContext {
-	return &LoadContext{}
-}
-
-// SaveContext provides context for saving operations
-type SaveContext struct {
-	// Add any context fields needed for saving
-	// e.g., output directories, formatting options, etc.
-}
-
-// NewSaveContext creates a new SaveContext
-func NewSaveContext() *SaveContext {
-	return &SaveContext{}
-}
diff --git a/schema/emitter/src/templates/go/file.go.njk b/schema/emitter/src/templates/go/file.go.njk
deleted file mode 100644
index de052222..00000000
--- a/schema/emitter/src/templates/go/file.go.njk
+++ /dev/null
@@ -1,160 +0,0 @@
-{#
-  Go Struct File Template
-  =======================
-  Renders Go struct definitions with JSON/YAML serialization.
-
-  Expected context (GoFileContext):
-    - packageName: string
-    - containsAbstract: boolean
-    - imports: string[]
-    - classes: GoClassContext[]
-    - typeMapper: Record<string, string>
-#}
-{% import "_macros.njk" as go %}
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-package {{ packageName }}
-
-import (
-	"encoding/json"
-
-	"gopkg.in/yaml.v3"
-)
-
-{% for class in classes %}
-{%- if class.node.description %}
-{{ go.goComment(class.node.typeName.name + " represents " + class.node.description) -}}
-{%- else %}
-// {{ class.node.typeName.name }} represents a schema type
-{%- endif %}
-type {{ class.node.typeName.name }} struct {
-{%- for prop in class.node.properties %}
-	{{ go.propName(prop.name) }} {{ go.goType(prop, typeMapper, polymorphicTypeNames) }} {{ go.structTags(prop) }}
-{%- endfor %}
-}
-
-// Load{{ class.node.typeName.name }} creates a {{ class.node.typeName.name }} from a map[string]interface{}
-{% if class.polymorphicTypes -%}
-// Returns interface{} because this is a polymorphic base type that can resolve to different child types
-func Load{{ class.node.typeName.name }}(data interface{}, ctx *LoadContext) (interface{}, error) {
-{%- else -%}
-func Load{{ class.node.typeName.name }}(data interface{}, ctx *LoadContext) ({{ class.node.typeName.name }}, error) {
-{%- endif %}
-	result := {{ class.node.typeName.name }}{}
-
-	{% if class.polymorphicTypes -%}
-	// Handle polymorphic types based on discriminator
-	if m, ok := data.(map[string]interface{}); ok {
-		if discriminator, ok := m["{{ class.node.discriminator }}"]; ok {
-			switch discriminator {
-			{%- for polyType in class.polymorphicTypes.types %}
-			case "{{ polyType.value }}":
-				return Load{{ polyType.instance.typeName.name }}(data, ctx)
-			{%- endfor %}
-			{%- if class.polymorphicTypes.default and class.polymorphicTypes.default.instance.typeName.name != class.node.typeName.name %}
-			default:
-				return Load{{ class.polymorphicTypes.default.instance.typeName.name }}(data, ctx)
-			{%- endif %}
-			}
-		}
-	}
-	{% endif -%}
-
-	{% if class.alternates.length > 0 -%}
-	// Handle alternate scalar representations
-	switch v := data.(type) {
-	{%- for alt in class.alternates %}
-	case {{ alt.scalar }}:
-		// Shorthand: {{ alt.scalar }} -> {{ class.node.typeName.name }}
-		expansion := map[string]interface{}{{ alt.alternate }}
-		return Load{{ class.node.typeName.name }}(expansion, ctx)
-	{%- endfor %}
-	}
-	{% endif -%}
-
-	// Load from map
-	if m, ok := data.(map[string]interface{}); ok {
-{%- for prop in class.node.properties %}
-		{{ go.loadProperty(prop, "m", typeMapper, polymorphicTypeNames) }}
-{%- endfor %}
-	}
-
-	return result, nil
-}
-
-// Save serializes {{ class.node.typeName.name }} to map[string]interface{}
-func (obj *{{ class.node.typeName.name }}) Save(ctx *SaveContext) map[string]interface{} {
-	result := make(map[string]interface{})
-{%- for prop in class.node.properties %}
-	{{ go.saveProperty(prop, polymorphicTypeNames) }}
-{%- endfor %}
-
-	return result
-}
-
-// ToJSON serializes {{ class.node.typeName.name }} to JSON string
-func (obj *{{ class.node.typeName.name }}) ToJSON() (string, error) {
-	ctx := NewSaveContext()
-	data := obj.Save(ctx)
-	bytes, err := json.Marshal(data)
-	if err != nil {
-		return "", err
-	}
-	return string(bytes), nil
-}
-
-// ToYAML serializes {{ class.node.typeName.name }} to YAML string
-func (obj *{{ class.node.typeName.name }}) ToYAML() (string, error) {
-	ctx := NewSaveContext()
-	data := obj.Save(ctx)
-	bytes, err := yaml.Marshal(data)
-	if err != nil {
-		return "", err
-	}
-	return string(bytes), nil
-}
-
-// FromJSON creates {{ class.node.typeName.name }} from JSON string
-{% if class.polymorphicTypes -%}
-// Returns interface{} because this is a polymorphic base type that can resolve to different child types
-func {{ class.node.typeName.name }}FromJSON(jsonStr string) (interface{}, error) {
-	var data map[string]interface{}
-	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
-		return nil, err
-	}
-	ctx := NewLoadContext()
-	return Load{{ class.node.typeName.name }}(data, ctx)
-}
-
-// FromYAML creates {{ class.node.typeName.name }} from YAML string
-// Returns interface{} because this is a polymorphic base type that can resolve to different child types
-func {{ class.node.typeName.name }}FromYAML(yamlStr string) (interface{}, error) {
-	var data map[string]interface{}
-	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
-		return nil, err
-	}
-	ctx := NewLoadContext()
-	return Load{{ class.node.typeName.name }}(data, ctx)
-}
-{%- else -%}
-func {{ class.node.typeName.name }}FromJSON(jsonStr string) ({{ class.node.typeName.name }}, error) {
-	var data map[string]interface{}
-	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
-		return {{ class.node.typeName.name }}{}, err
-	}
-	ctx := NewLoadContext()
-	return Load{{ class.node.typeName.name }}(data, ctx)
-}
-
-// FromYAML creates {{ class.node.typeName.name }} from YAML string
-func {{ class.node.typeName.name }}FromYAML(yamlStr string) ({{ class.node.typeName.name }}, error) {
-	var data map[string]interface{}
-	if err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {
-		return {{ class.node.typeName.name }}{}, err
-	}
-	ctx := NewLoadContext()
-	return Load{{ class.node.typeName.name }}(data, ctx)
-}
-{%- endif %}
-
-{% endfor %}
diff --git a/schema/emitter/src/templates/go/test.go.njk b/schema/emitter/src/templates/go/test.go.njk
deleted file mode 100644
index ce4dd13b..00000000
--- a/schema/emitter/src/templates/go/test.go.njk
+++ /dev/null
@@ -1,269 +0,0 @@
-{#
-  Go Test Template
-  ================
-  Renders Go test file for a type.
-
-  Expected context (BaseTestContext):
-    - node: TypeNode
-    - package: string
-    - examples: Array<{ json: string[], yaml: string[], validations: Array<{ key, value, delimiter, isOptional }> }>
-    - alternates: Array<{ title, scalarType, value, validations: Array<{ key, value, delimiter, isOptional }> }>
-#}
-{% import "_macros.njk" as go %}
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-package {{ package }}_test
-
-import (
-"encoding/json"
-"testing"
-
-"gopkg.in/yaml.v3"
-
-"github.com/microsoft/agentschema-go/{{ package }}"
-)
-
-{% for sample in examples %}
-// Test{{ node.typeName.name }}LoadJSON{% if not loop.first %}{{ loop.index - 1 }}{% endif %} tests loading {{ node.typeName.name }} from JSON
-func Test{{ node.typeName.name }}LoadJSON{% if not loop.first %}{{ loop.index - 1 }}{% endif %}(t *testing.T) {
-jsonData := `
-{%- for line in sample.json %}
-{{ line }}
-{%- endfor %}
-`
-var data map[string]interface{}
-if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
-t.Fatalf("Failed to parse JSON: %v", err)
-}
-
-ctx := {{ package }}.NewLoadContext()
-instance, err := {{ package }}.Load{{ node.typeName.name }}(data, ctx)
-if err != nil {
-t.Fatalf("Failed to load {{ node.typeName.name }}: %v", err)
-}
-
-{%- if isAbstract %}
-// Polymorphic types return interface{}, extract common fields via reflection or type-specific access
-_ = instance // Load succeeded, exact type depends on discriminator
-{%- if sample.validations.length > 0 %}
-// Note: Validation skipped for polymorphic base types - test child types directly
-{%- endif %}
-{%- else %}
-{%- if sample.validations.length > 0 %}
-{%- for validation in sample.validations %}
-{%- if validation.isOptional %}
-if instance.{{ validation.key }} == nil || *instance.{{ validation.key }} != {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }} {
-t.Errorf(`Expected {{ validation.key }} to be {% if validation.delimiter == '"' %}"{% endif %}{{ validation.value }}{% if validation.delimiter == '"' %}"{% endif %}, got %v`, instance.{{ validation.key }})
-}
-{%- else %}
-if instance.{{ validation.key }} != {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }} {
-t.Errorf(`Expected {{ validation.key }} to be {% if validation.delimiter == '"' %}"{% endif %}{{ validation.value }}{% if validation.delimiter == '"' %}"{% endif %}, got %v`, instance.{{ validation.key }})
-}
-{%- endif %}
-{%- endfor %}
-{%- else %}
-_ = instance // No scalar properties to validate
-{%- endif %}
-{%- endif %}
-}
-
-// Test{{ node.typeName.name }}LoadYAML{% if not loop.first %}{{ loop.index - 1 }}{% endif %} tests loading {{ node.typeName.name }} from YAML
-func Test{{ node.typeName.name }}LoadYAML{% if not loop.first %}{{ loop.index - 1 }}{% endif %}(t *testing.T) {
-yamlData := `
-{%- for line in sample.yaml %}
-{{ line }}
-{%- endfor %}
-`
-var data map[string]interface{}
-if err := yaml.Unmarshal([]byte(yamlData), &data); err != nil {
-t.Fatalf("Failed to parse YAML: %v", err)
-}
-
-ctx := {{ package }}.NewLoadContext()
-instance, err := {{ package }}.Load{{ node.typeName.name }}(data, ctx)
-if err != nil {
-t.Fatalf("Failed to load {{ node.typeName.name }}: %v", err)
-}
-
-{%- if isAbstract %}
-// Polymorphic types return interface{}, extract common fields via reflection or type-specific access
-_ = instance // Load succeeded, exact type depends on discriminator
-{%- if sample.validations.length > 0 %}
-// Note: Validation skipped for polymorphic base types - test child types directly
-{%- endif %}
-{%- else %}
-{%- if sample.validations.length > 0 %}
-{%- for validation in sample.validations %}
-{%- if validation.isOptional %}
-if instance.{{ validation.key }} == nil || *instance.{{ validation.key }} != {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }} {
-t.Errorf(`Expected {{ validation.key }} to be {% if validation.delimiter == '"' %}"{% endif %}{{ validation.value }}{% if validation.delimiter == '"' %}"{% endif %}, got %v`, instance.{{ validation.key }})
-}
-{%- else %}
-if instance.{{ validation.key }} != {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }} {
-t.Errorf(`Expected {{ validation.key }} to be {% if validation.delimiter == '"' %}"{% endif %}{{ validation.value }}{% if validation.delimiter == '"' %}"{% endif %}, got %v`, instance.{{ validation.key }})
-}
-{%- endif %}
-{%- endfor %}
-{%- else %}
-_ = instance // No scalar properties to validate
-{%- endif %}
-{%- endif %}
-}
-
-// Test{{ node.typeName.name }}Roundtrip{% if not loop.first %}{{ loop.index - 1 }}{% endif %} tests load -> save -> load produces equivalent data
-func Test{{ node.typeName.name }}Roundtrip{% if not loop.first %}{{ loop.index - 1 }}{% endif %}(t *testing.T) {
-jsonData := `
-{%- for line in sample.json %}
-{{ line }}
-{%- endfor %}
-`
-var data map[string]interface{}
-if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
-t.Fatalf("Failed to parse JSON: %v", err)
-}
-
-loadCtx := {{ package }}.NewLoadContext()
-instance, err := {{ package }}.Load{{ node.typeName.name }}(data, loadCtx)
-if err != nil {
-t.Fatalf("Failed to load {{ node.typeName.name }}: %v", err)
-}
-
-{%- if isAbstract %}
-// Polymorphic roundtrip testing requires type-specific handling
-_ = instance // Load succeeded, exact type depends on discriminator
-// Note: Roundtrip test skipped for polymorphic base types - test child types directly
-{%- else %}
-saveCtx := {{ package }}.NewSaveContext()
-savedData := instance.Save(saveCtx)
-
-reloaded, err := {{ package }}.Load{{ node.typeName.name }}(savedData, loadCtx)
-if err != nil {
-t.Fatalf("Failed to reload {{ node.typeName.name }}: %v", err)
-}
-
-{%- if sample.validations.length > 0 %}
-{%- for validation in sample.validations %}
-{%- if validation.isOptional %}
-if reloaded.{{ validation.key }} == nil || *reloaded.{{ validation.key }} != {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }} {
-t.Errorf(`Expected {{ validation.key }} to be {% if validation.delimiter == '"' %}"{% endif %}{{ validation.value }}{% if validation.delimiter == '"' %}"{% endif %}, got %v`, reloaded.{{ validation.key }})
-}
-{%- else %}
-if reloaded.{{ validation.key }} != {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }} {
-t.Errorf(`Expected {{ validation.key }} to be {% if validation.delimiter == '"' %}"{% endif %}{{ validation.value }}{% if validation.delimiter == '"' %}"{% endif %}, got %v`, reloaded.{{ validation.key }})
-}
-{%- endif %}
-{%- endfor %}
-{%- else %}
-_ = reloaded // No scalar properties to validate
-{%- endif %}
-{%- endif %}
-}
-
-// Test{{ node.typeName.name }}ToJSON{% if not loop.first %}{{ loop.index - 1 }}{% endif %} tests that ToJSON produces valid JSON
-func Test{{ node.typeName.name }}ToJSON{% if not loop.first %}{{ loop.index - 1 }}{% endif %}(t *testing.T) {
-jsonData := `
-{%- for line in sample.json %}
-{{ line }}
-{%- endfor %}
-`
-var data map[string]interface{}
-if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
-t.Fatalf("Failed to parse JSON: %v", err)
-}
-
-ctx := {{ package }}.NewLoadContext()
-instance, err := {{ package }}.Load{{ node.typeName.name }}(data, ctx)
-if err != nil {
-t.Fatalf("Failed to load {{ node.typeName.name }}: %v", err)
-}
-
-{%- if isAbstract %}
-// Polymorphic ToJSON requires type-specific handling
-_ = instance // Load succeeded, exact type depends on discriminator
-// Note: ToJSON test skipped for polymorphic base types - test child types directly
-{%- else %}
-jsonOutput, err := instance.ToJSON()
-if err != nil {
-t.Fatalf("Failed to convert to JSON: %v", err)
-}
-
-var parsed map[string]interface{}
-if err := json.Unmarshal([]byte(jsonOutput), &parsed); err != nil {
-t.Fatalf("Failed to parse generated JSON: %v", err)
-}
-{%- endif %}
-}
-
-// Test{{ node.typeName.name }}ToYAML{% if not loop.first %}{{ loop.index - 1 }}{% endif %} tests that ToYAML produces valid YAML
-func Test{{ node.typeName.name }}ToYAML{% if not loop.first %}{{ loop.index - 1 }}{% endif %}(t *testing.T) {
-jsonData := `
-{%- for line in sample.json %}
-{{ line }}
-{%- endfor %}
-`
-var data map[string]interface{}
-if err := json.Unmarshal([]byte(jsonData), &data); err != nil {
-t.Fatalf("Failed to parse JSON: %v", err)
-}
-
-ctx := {{ package }}.NewLoadContext()
-instance, err := {{ package }}.Load{{ node.typeName.name }}(data, ctx)
-if err != nil {
-t.Fatalf("Failed to load {{ node.typeName.name }}: %v", err)
-}
-
-{%- if isAbstract %}
-// Polymorphic ToYAML requires type-specific handling
-_ = instance // Load succeeded, exact type depends on discriminator
-// Note: ToYAML test skipped for polymorphic base types - test child types directly
-{%- else %}
-yamlOutput, err := instance.ToYAML()
-if err != nil {
-t.Fatalf("Failed to convert to YAML: %v", err)
-}
-
-var parsed map[string]interface{}
-if err := yaml.Unmarshal([]byte(yamlOutput), &parsed); err != nil {
-t.Fatalf("Failed to parse generated YAML: %v", err)
-}
-{%- endif %}
-}
-
-{% endfor %}
-{% if alternates.length > 0 %}
-{% for alt in alternates %}
-// Test{{ node.typeName.name }}From{{ alt.title | capitalize }}{% if not loop.first %}{{ loop.index }}{% endif %} tests loading {{ node.typeName.name }} from {{ alt.scalarType }}
-func Test{{ node.typeName.name }}From{{ alt.title | capitalize }}{% if not loop.first %}{{ loop.index }}{% endif %}(t *testing.T) {
-ctx := {{ package }}.NewLoadContext()
-instance, err := {{ package }}.Load{{ node.typeName.name }}({{ alt.value }}, ctx)
-if err != nil {
-t.Fatalf("Failed to load {{ node.typeName.name }} from {{ alt.scalarType }}: %v", err)
-}
-
-{%- if isAbstract %}
-// Polymorphic alternate loading requires type-specific handling
-_ = instance // Load succeeded, exact type depends on discriminator
-{%- if alt.validations.length > 0 %}
-// Note: Validation skipped for polymorphic base types - test child types directly
-{%- endif %}
-{%- else %}
-{%- if alt.validations.length > 0 %}
-{%- for item in alt.validations %}
-{%- if item.isOptional %}
-if instance.{{ item.key }} == nil || *instance.{{ item.key }} != {{ item.delimiter }}{{ item.value }}{{ item.delimiter }} {
-t.Errorf(`Expected {{ item.key }} to be {% if item.delimiter == '"' %}"{% endif %}{{ item.value }}{% if item.delimiter == '"' %}"{% endif %}, got %v`, instance.{{ item.key }})
-}
-{%- else %}
-if instance.{{ item.key }} != {{ item.delimiter }}{{ item.value }}{{ item.delimiter }} {
-t.Errorf(`Expected {{ item.key }} to be {% if item.delimiter == '"' %}"{% endif %}{{ item.value }}{% if item.delimiter == '"' %}"{% endif %}, got %v`, instance.{{ item.key }})
-}
-{%- endif %}
-{%- endfor %}
-{%- else %}
-_ = instance // No scalar properties to validate
-{%- endif %}
-{%- endif %}
-}
-
-{% endfor %}
-{% endif %}
diff --git a/schema/emitter/src/templates/markdown/file.md.njk b/schema/emitter/src/templates/markdown/file.md.njk
deleted file mode 100644
index b360002b..00000000
--- a/schema/emitter/src/templates/markdown/file.md.njk
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: "{{ node.typeName.name }}"
-description: "Documentation for the {{ node.typeName.name }} type."
-slug: "reference/{{ node.typeName.name | lower }}"
----
-
-{{ node.description }}
-
-## Class Diagram
-
-```mermaid
----
-title: {{ node.typeName.name }}
-config:
-  look: handDrawn
-  theme: colorful
-  class:
-    hideEmptyMembersBox: true
----
-classDiagram
-    {%- if parent %}
-    class {{ parent.typeName.name }} {
-      {%- for prop in parent.properties %}
-        +{{ prop.typeName.name | safe }}{{ "[]" if prop.isCollection else "" }} {{ prop.name }}
-      {%- endfor %}
-    }
-    {{ parent.typeName.name }} <|-- {{ node.typeName.name }}
-    {%- endif %}
-    class {{ node.typeName.name }} {
-      {% if node.isAbstract %}<<abstract>>{% endif %}
-      {%- for prop in node.properties %}
-        +{{ prop.typeName.name }}{{ "[]" if prop.isCollection else "" }} {{ prop.name }}
-      {%- endfor %}
-    }
-    {%- for type in node.childTypes %}
-    class {{ type.typeName.name }} {
-      {%- for prop in type.properties %}
-        +{{ prop.typeName.name | safe }}{{ "[]" if prop.isCollection else "" }} {{ prop.name }}
-      {%- endfor %}
-    }
-    {{ node.typeName.name }} <|-- {{ type.typeName.name }}
-    {%- endfor %}
-    {%- for type in compositionTypes %}
-    class {{ type.typeName.name }} {
-      {%- for prop in type.properties %}
-        +{{ prop.typeName.name | safe }}{{ "[]" if prop.isCollection else "" }} {{ prop.name }}
-      {%- endfor %}
-    }
-    {{ node.typeName.name }} *-- {{ type.typeName.name }}
-    {%- endfor %}
-```
-{%- if md %}
-
-## Markdown Example
-
-```markdown
-{{ md | safe | trim }}
-```
-{%- endif %}
-{%- if yml %}
-
-## Yaml Example
-
-```yaml
-{{ yml | safe | trim }}
-```
-{%- endif %}
-{%- if node.properties.length > 0 %}
-
-## Properties
-
-| Name | Type | Description |
-| ---- | ---- | ----------- |
-{%- for prop in node.properties %}
-| {{ prop.name }} | {{ renderType(prop) }} | {{ prop.description | trim }}{{ renderChildTypes(prop) | safe }} |
-{%- endfor %}
-{%- endif %}
-{%- if node.childTypes.length > 0 %}
-
-## Child Types
-
-The following types extend `{{ node.typeName.name }}`:
-{% for type in node.childTypes %}
-- [{{ type.typeName.name }}](../{{ type.typeName.name | lower }}/)
-{%- endfor %}
-{%- endif %}
-{%- if compositionTypes.length > 0 %}
-
-## Composed Types
-
-The following types are composed within `{{ node.typeName.name }}`:
-{% for type in compositionTypes %}
-- [{{ type.typeName.name }}](../{{ type.typeName.name | lower }}/)
-{%- endfor %}
-{%- endif %}
-{%- if alternateCtors.length > 0 %}
-
-## Alternate Constructions
-
-The following alternate constructions are available for `{{ node.typeName.name }}`.
-These allow for simplified creation of instances using a single property.
-{%- for ctor in alternateCtors %}
-
-### {{ ctor.scalar }}{% if ctor.title %} {{ ctor.title }}{% endif %}
-
-{% if ctor.description %}{{ ctor.description }}
-
-{% endif -%}
-The following simplified representation can be used:
-
-```yaml
-{{ ctor.simple | safe | trim }}
-```
-
-This is equivalent to the full representation:
-
-```yaml
-{{ ctor.expanded | safe | trim }}
-```
-{%- endfor %}
-{%- endif %}
diff --git a/schema/emitter/src/templates/markdown/index.md.njk b/schema/emitter/src/templates/markdown/index.md.njk
deleted file mode 100644
index d004e8ae..00000000
--- a/schema/emitter/src/templates/markdown/index.md.njk
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: "AgentSchema"
-description: "Overview of declarative agent types in AgentSchema."
-slug: "reference/index"
-sidebar:
-  order: 1
----
-
-The following diagram illustrates the classes and their relationships for declarative agents.
-The root [object]({{ rootObject | lower }}/) represents the main entry point for the system.
-
-```mermaid
----
-title: {{ rootObject }} and Related Types
-config:
-  look: handDrawn
-  theme: colorful
-  class:
-    hideEmptyMembersBox: true
----
-classDiagram
-    {%- for type in types %}
-    class {{ type.typeName.name }} {
-      {% if type.isAbstract %}<<abstract>>{% endif %}
-      {%- for prop in type.properties %}
-        +{{ prop.typeName.name }}{{ "[]" if prop.isCollection else "" }} {{ prop.name }}
-      {%- endfor %}
-    }
-    {%- endfor -%}
-    {%- for child in childTypes %}
-    {{ child.source }} <|-- {{ child.target }}
-    {%- endfor -%}
-    {%- for comp in compositionTypes %}
-    {{ comp.source }} *-- {{ comp.target }}
-    {%- endfor %}
-```
diff --git a/schema/emitter/src/templates/python/_macros.njk b/schema/emitter/src/templates/python/_macros.njk
deleted file mode 100644
index fa84fa96..00000000
--- a/schema/emitter/src/templates/python/_macros.njk
+++ /dev/null
@@ -1,296 +0,0 @@
-{#
-  Python-Specific Macros for AgentSchema Emitter
-  ==============================================
-
-  These macros handle Python-specific rendering logic that was previously
-  implemented as TypeScript functions passed to templates. By moving this
-  logic into macros, templates become self-contained and easier to debug.
-
-  Usage in Python templates:
-    {% import "_macros.njk" as py %}
-    {{ py.pythonType(prop, typeMapper) }}
-#}
-
-{# Import shared macros #}
-{% from "macros.njk" import separator, firstOrDefault, validationValue %}
-
-
-{# ============================================================================
-   Type Rendering
-   ============================================================================ #}
-
-{#
-  Convert a property to its Python type annotation.
-
-  Handles:
-  - Scalar types (string -> str, number -> float, etc.)
-  - Collections (list[T])
-  - Optionals (Optional[T])
-  - Dictionaries (dict[str, Any])
-  - Optional dictionaries (Optional[dict[str, Any]])
-
-  @param prop - PropertyNode with type information
-  @param typeMapper - Record<string, string> mapping TypeSpec types to Python types
-
-  Usage: {{ pythonType(prop, typeMapper) }}
-#}
-{% macro pythonType(prop, typeMapper) %}
-{%- set baseType = typeMapper[prop.typeName.name] if prop.isScalar else (typeMapper[prop.typeName.name] or prop.typeName.name) -%}
-{%- if not baseType %}{% set baseType = "Any" %}{% endif -%}
-{%- if prop.isDict and prop.isOptional -%}
-Optional[dict[str, Any]]
-{%- elif prop.isDict -%}
-dict[str, Any]
-{%- elif prop.isCollection -%}
-list[{{ baseType }}]
-{%- elif prop.isOptional -%}
-Optional[{{ baseType }}]
-{%- else -%}
-{{ baseType }}
-{%- endif -%}
-{% endmacro %}
-
-
-{#
-  Render the Python type for display in docstrings.
-  Same as pythonType but uses Optional[] syntax for clarity.
-
-  @param prop - PropertyNode with type information
-  @param typeMapper - Record<string, string> mapping TypeSpec types to Python types
-#}
-{% macro pythonTypeDocstring(prop, typeMapper) %}
-{%- set baseType = typeMapper[prop.typeName.name] if prop.isScalar else (typeMapper[prop.typeName.name] or prop.typeName.name) -%}
-{%- if not baseType %}{% set baseType = "Any" %}{% endif -%}
-{%- if prop.isDict -%}
-dict[str, Any]
-{%- elif prop.isCollection -%}
-list[{{ baseType }}]
-{%- else -%}
-{{ baseType }}
-{%- endif -%}
-{%- if prop.isOptional %}Optional[{{ baseType }}]{% endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Default Value Rendering
-   ============================================================================ #}
-
-{#
-  Render the default value assignment for a dataclass field.
-
-  Handles:
-  - Collections -> field(default_factory=list)
-  - Optionals -> None
-  - Booleans -> field(default=True/False)
-  - Strings -> field(default="...")
-  - Numbers -> field(default=0.0)
-  - Complex types -> field(default_factory=TypeName)
-
-  @param prop - PropertyNode with type and default value information
-  @param typeMapper - Record<string, string> for type lookups
-
-  Usage: {{ defaultValue(prop, typeMapper) }}
-#}
-{% macro defaultValue(prop, typeMapper) -%}
-{% if prop.isCollection %} = field(default_factory=list)
-{%- elif prop.isOptional %} = None
-{%- elif prop.isScalar -%}
-{%- if prop.typeName.name == "boolean" %} = field(default={{ "True" if prop.defaultValue else "False" }})
-{%- elif prop.typeName.name == "string" %} = field(default="{{ prop.defaultValue if prop.defaultValue else "" }}")
-{%- elif prop.typeName.name == "number" or prop.typeName.name == "numeric" %} = field(default={{ prop.defaultValue if prop.defaultValue else "0.0" }})
-{%- elif prop.typeName.name == "dictionary" %} = field(default_factory=dict)
-{%- elif prop.typeName.name == "int64" or prop.typeName.name == "int32" or prop.typeName.name == "integer" %} = field(default={{ prop.defaultValue if prop.defaultValue else "0" }})
-{%- elif prop.typeName.name == "float64" or prop.typeName.name == "float32" or prop.typeName.name == "float" %} = field(default={{ prop.defaultValue if prop.defaultValue else "0.0" }})
-{%- else %} = field(default={{ prop.defaultValue if prop.defaultValue else "None" }})
-{%- endif -%}
-{%- else %} = field(default_factory={{ prop.typeName.name }})
-{%- endif -%}
-{%- endmacro %}
-
-
-{# ============================================================================
-   Property Assignment Rendering (for load() method)
-   ============================================================================ #}
-
-{#
-  Render property assignment statement for loading from dict.
-
-  Handles:
-  - Scalars and dicts -> direct assignment from dict
-  - Collections -> call load_<propname> method
-  - Complex types -> call Type.load() method
-
-  @param prop - PropertyNode being assigned
-  @param varName - Variable name to assign to (e.g., "instance")
-  @param dictName - Dict variable name to read from (e.g., "data")
-  @param parentTypeName - Name of the parent type (for collection loaders)
-
-  Usage: {{ setInstance(prop, "instance", "data", node.typeName.name) }}
-#}
-{% macro setInstance(prop, varName, dictName, parentTypeName) %}
-{%- if prop.isScalar or prop.isDict -%}
-{{ varName }}.{{ prop.name }} = {{ dictName }}["{{ prop.name }}"]
-{%- elif prop.isCollection -%}
-{{ varName }}.{{ prop.name }} = {{ parentTypeName }}.load_{{ prop.name }}({{ dictName }}["{{ prop.name }}"], context)
-{%- else -%}
-{{ varName }}.{{ prop.name }} = {{ prop.typeName.name }}.load({{ dictName }}["{{ prop.name }}"], context)
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Property Serialization Rendering (for save() method)
-   ============================================================================ #}
-
-{#
-  Render property serialization statement for saving to dict.
-
-  Handles:
-  - Scalars and dicts -> direct assignment to dict
-  - Collections -> map save() over items
-  - Complex types -> call .save() method
-
-  @param prop - PropertyNode being serialized
-  @param varName - Variable name of the object (e.g., "self")
-  @param dictName - Dict variable name to write to (e.g., "result")
-
-  Usage: {{ saveProperty(prop, "self", "result") }}
-#}
-{% macro saveProperty(prop, varName, dictName, parentTypeName) %}
-{%- if prop.isScalar or prop.isDict -%}
-{{ dictName }}["{{ prop.name }}"] = {{ varName }}.{{ prop.name }}
-{%- elif prop.isCollection -%}
-{{ dictName }}["{{ prop.name }}"] = {{ parentTypeName }}.save_{{ prop.name }}({{ varName }}.{{ prop.name }}, context)
-{%- else -%}
-{{ dictName }}["{{ prop.name }}"] = {{ varName }}.{{ prop.name }}.save(context)
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Docstring Rendering
-   ============================================================================ #}
-
-{#
-  Render a Python docstring with proper formatting.
-
-  @param description - The description text
-
-  Usage: {{ docstring(node.description) }}
-#}
-{% macro docstring(description) %}
-{%- if description -%}
-"""{%- for line in description.split('\n') %}
-    {{ line }}
-    {%- endfor %}
-    """
-{%- endif -%}
-{% endmacro %}
-
-
-{#
-  Render a docstring for a class with attributes section.
-
-  @param description - Class description
-  @param properties - Array of PropertyNode
-  @param typeMapper - Type mapper for rendering types
-
-  Usage: {{ classDocstring(node.description, node.properties, typeMapper) }}
-#}
-{% macro classDocstring(description, properties, typeMapper) %}
-"""{%- for line in description.split('\n') %}
-    {{ line }}
-    {%- endfor %}
-{%- if properties.length > 0 %}
-
-    Attributes
-    ----------
-{%- for prop in properties %}
-    {{ prop.name }} : {{ pythonType(prop, typeMapper) }}
-        {{ prop.description }}
-{%- endfor %}
-{%- endif %}
-    """
-{% endmacro %}
-
-
-{# ============================================================================
-   Import Helpers
-   ============================================================================ #}
-
-{#
-  Render import statement for a type from its module.
-
-  @param typeName - Name of the type to import
-
-  Usage: {{ importType(typeName) }}
-#}
-{% macro importType(typeName) %}
-from ._{{ typeName }} import {{ typeName }}
-{% endmacro %}
-
-
-{# ============================================================================
-   Alternate/Shorthand Helpers
-   ============================================================================ #}
-
-{#
-  Render alternate type check in load() method.
-
-  @param alt - Alternate object with scalar and alternate properties
-
-  Usage: {{ alternateCheck(alt) }}
-#}
-{% macro alternateCheck(alt) %}
-if isinstance(data, {{ alt.scalar }}):
-    data = {{ alt.alternate }}
-{% endmacro %}
-
-
-{# ============================================================================
-   Polymorphism Helpers
-   ============================================================================ #}
-
-{#
-  Render discriminator-based type loading.
-
-  @param discriminator - Name of discriminator property
-  @param types - Array of {value, instance} for each discriminated type
-  @param defaultInstance - Default instance for unknown discriminators
-  @param parentTypeName - Name of the parent type
-  @param isAbstract - Whether the parent type is abstract
-
-  Usage: {{ polymorphicLoader(node.discriminator, polymorphicTypes.types, polymorphicTypes.default, node.typeName.name, node.isAbstract) }}
-#}
-{% macro polymorphicLoader(discriminator, types, defaultInstance, parentTypeName, isAbstract) %}
-@staticmethod
-def load_{{ discriminator }}(data: dict, pre_process: Optional[Callable[[Any], Any]]) -> "{{ parentTypeName }}":
-    # load polymorphic {{ parentTypeName }} instance
-    if data is not None and "{{ discriminator }}" in data:
-        discriminator_value = str(data["{{ discriminator }}"]).lower()
-{%- for type in types %}
-        {% if loop.first %}if{% else %}elif{% endif %} discriminator_value == "{{ type.value }}":
-            return {{ type.instance.typeName.name }}.load(data, pre_process)
-{%- endfor %}
-{%- if defaultInstance %}
-        else:
-{%- if defaultInstance.instance.typeName.name == parentTypeName %}
-            # create new instance (stop recursion)
-            return {{ parentTypeName }}()
-{%- else %}
-            # load default instance
-            return {{ defaultInstance.instance.typeName.name }}.load(data, pre_process)
-{%- endif %}
-{%- else %}
-        else:
-            raise ValueError(f"Unknown {{ parentTypeName }} discriminator value: {discriminator_value}")
-{%- endif %}
-    else:
-{%- if isAbstract %}
-        raise ValueError("Missing {{ parentTypeName }} discriminator property: '{{ discriminator }}'")
-{%- else %}
-        # create new instance
-        return {{ parentTypeName }}()
-{%- endif %}
-{% endmacro %}
diff --git a/schema/emitter/src/templates/python/file.py.njk b/schema/emitter/src/templates/python/file.py.njk
deleted file mode 100644
index 444ed312..00000000
--- a/schema/emitter/src/templates/python/file.py.njk
+++ /dev/null
@@ -1,220 +0,0 @@
-{#
-  Python File Template
-  ====================
-  Renders a complete Python file containing one or more dataclasses.
-
-  Expected context (PythonFileContext):
-    - containsAbstract: boolean
-    - typings: string[]
-    - imports: string[]
-    - classes: PythonClassContext[]
-    - typeMapper: Record<string, string>
-#}
-{%- import "_macros.njk" as py -%}
-##########################################
-# WARNING: This is an auto-generated file.
-# DO NOT EDIT THIS FILE DIRECTLY
-# ANY EDITS WILL BE LOST
-##########################################
-{% if containsAbstract %}
-from abc import ABC
-{%- endif %}
-from dataclasses import dataclass, field
-from typing import Any, ClassVar, Optional
-
-from ._context import LoadContext, SaveContext
-{%- for import in imports %}
-from ._{{ import }} import {{ import }}
-{%- endfor %}
-
-{% for classCtx in classes %}
-{%- set node = classCtx.node -%}
-{%- set typeMapper = classCtx.typeMapper -%}
-{%- set alternates = classCtx.alternates -%}
-{%- set polymorphicTypes = classCtx.polymorphicTypes -%}
-{%- set collectionTypes = classCtx.collectionTypes %}
-
-@dataclass
-class {{ node.typeName.name }}{% if node.base %}({{ node.base.name }}){% endif %}{% if node.isAbstract %}(ABC){% endif %}:
-    """{% for line in node.description.split('\n') %}{{ line }}
-    {% endfor %}
-    Attributes
-    ----------
-{%- for prop in node.properties %}
-    {{ prop.name }} : {{ py.pythonType(prop, typeMapper) }}
-        {{ prop.description }}
-{%- endfor %}
-    """
-
-    _shorthand_property: ClassVar[Optional[str]] = {% if classCtx.shorthandProperty %}"{{ classCtx.shorthandProperty }}"{% else %}None{% endif %}
-{% for prop in node.properties %}
-    {{ prop.name }}: {{ py.pythonType(prop, typeMapper) }}{{ py.defaultValue(prop, typeMapper) }}
-{%- endfor %}
-
-    @staticmethod
-    def load(data: Any, context: Optional[LoadContext] = None) -> "{{ node.typeName.name }}":
-        """Load a {{ node.typeName.name }} instance.
-        Args:
-            data (Any): The data to load the instance from.
-            context (Optional[LoadContext]): Optional context with pre/post processing callbacks.
-        Returns:
-            {{ node.typeName.name }}: The loaded {{ node.typeName.name }} instance.
-
-        """
-
-        if context is not None:
-            data = context.process_input(data)
-        {% if alternates.length > 0 %}
-        # handle alternate representations
-{%- for alt in alternates %}
-        if isinstance(data, {{ alt.scalar }}):
-            data = {{ alt.alternate }}
-{%- endfor %}
-        {% endif %}
-        if not isinstance(data, dict):
-            raise ValueError(f"Invalid data for {{ node.typeName.name }}: {data}")
-{% if polymorphicTypes %}
-        # load polymorphic {{ node.typeName.name }} instance
-        instance = {{ node.typeName.name }}.load_{{ node.discriminator }}(data, context)
-{% else %}
-        # create new instance
-        instance = {{ node.typeName.name }}()
-{%- endif %}
-{% for prop in node.properties %}
-        if data is not None and "{{ prop.name }}" in data:
-            {{ py.setInstance(prop, "instance", "data", node.typeName.name) }}
-{%- endfor %}
-        if context is not None:
-            instance = context.process_output(instance)
-        return instance
-{% for collection in collectionTypes %}
-
-    @staticmethod
-    def load_{{ collection.prop.name }}(data: dict | list, context: Optional[LoadContext]) -> list[{{ collection.prop.typeName.name }}]:
-        if isinstance(data, dict):
-            # convert simple named {{ collection.prop.name }} to list of {{ collection.prop.typeName.name }}
-            result = []
-            for k, v in data.items():
-                if isinstance(v, dict):
-                    # value is an object, spread its properties
-                    result.append({"name": k, **v})
-                else:
-                    # value is a scalar, use it as the primary property
-                    result.append({"name": k, "{{collection.type[0]}}": v})
-            data = result
-        return [{{ collection.prop.typeName.name }}.load(item, context) for item in data]
-
-    @staticmethod
-    def save_{{ collection.prop.name }}(items: list[{{ collection.prop.typeName.name }}], context: Optional[SaveContext]) -> dict[str, Any] | list[dict[str, Any]]:
-        if context is None:
-            context = SaveContext()
-
-        if context.collection_format == "array":
-            return [item.save(context) for item in items]
-
-        # Object format: use name as key
-        result: dict[str, Any] = {}
-        for item in items:
-            item_data = item.save(context)
-            name = item_data.pop("name", None)
-            if name:
-                # Check if we can use shorthand (only primary property set)
-                if context.use_shorthand and hasattr(item, '_shorthand_property'):
-                    shorthand_prop = item._shorthand_property
-                    if shorthand_prop and len(item_data) == 1 and shorthand_prop in item_data:
-                        result[name] = item_data[shorthand_prop]
-                        continue
-                result[name] = item_data
-            else:
-                # No name, fall back to array format for this item
-                if "_unnamed" not in result:
-                    result["_unnamed"] = []
-                result["_unnamed"].append(item_data)
-        return result
-{%- endfor %}
-{% if polymorphicTypes %}
-
-    @staticmethod
-    def load_{{ node.discriminator }}(data: dict, context: Optional[LoadContext]) -> "{{ node.typeName.name }}":
-        # load polymorphic {{ node.typeName.name }} instance
-        if data is not None and "{{ node.discriminator }}" in data:
-            discriminator_value = str(data["{{ node.discriminator }}"]).lower()
-{%- for type in polymorphicTypes.types %}
-            {% if loop.first %}if{% else %}elif{% endif %} discriminator_value == "{{ type.value }}":
-                return {{ type.instance.typeName.name }}.load(data, context)
-{%- endfor %}
-{% if polymorphicTypes.default %}
-            else:
-{% if polymorphicTypes.default.instance.typeName.name == node.typeName.name %}
-                # create new instance (stop recursion)
-                return {{ node.typeName.name }}()
-{% else %}
-                # load default instance
-                return {{ polymorphicTypes.default.instance.typeName.name }}.load(data, context)
-{%- endif %}
-{% else %}
-            else:
-                raise ValueError(f"Unknown {{ node.typeName.name }} discriminator value: {discriminator_value}")
-{%- endif %}
-        else:
-{% if node.isAbstract %}
-            raise ValueError("Missing {{ node.typeName.name }} discriminator property: '{{ node.discriminator }}'")
-{% else %}
-            # create new instance
-            return {{ node.typeName.name }}()
-{%- endif %}
-{%- endif %}
-
-    def save(self, context: Optional[SaveContext] = None) -> dict[str, Any]:
-        """Save the {{ node.typeName.name }} instance to a dictionary.
-        Args:
-            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
-        Returns:
-            dict[str, Any]: The dictionary representation of this instance.
-
-        """
-        obj = self
-        if context is not None:
-            obj = context.process_object(obj)
-
-{% if node.base %}
-        # Start with parent class properties
-        result = super().save(context)
-{% else %}
-        result: dict[str, Any] = {}
-{%- endif %}
-{% for prop in node.properties %}
-        if obj.{{ prop.name }} is not None:
-            {{ py.saveProperty(prop, "obj", "result", node.typeName.name) }}
-{%- endfor %}
-{% if not node.base %}
-        if context is not None:
-            result = context.process_dict(result)
-{%- endif %}
-        return result
-
-    def to_yaml(self, context: Optional[SaveContext] = None) -> str:
-        """Convert the {{ node.typeName.name }} instance to a YAML string.
-        Args:
-            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
-        Returns:
-            str: The YAML string representation of this instance.
-
-        """
-        if context is None:
-            context = SaveContext()
-        return context.to_yaml(self.save(context))
-
-    def to_json(self, context: Optional[SaveContext] = None, indent: int = 2) -> str:
-        """Convert the {{ node.typeName.name }} instance to a JSON string.
-        Args:
-            context (Optional[SaveContext]): Optional context with pre/post processing callbacks.
-            indent (int): Number of spaces for indentation. Defaults to 2.
-        Returns:
-            str: The JSON string representation of this instance.
-
-        """
-        if context is None:
-            context = SaveContext()
-        return context.to_json(self.save(context), indent)
-{% endfor %}
diff --git a/schema/emitter/src/templates/python/init.py.njk b/schema/emitter/src/templates/python/init.py.njk
deleted file mode 100644
index 5ef405d1..00000000
--- a/schema/emitter/src/templates/python/init.py.njk
+++ /dev/null
@@ -1,35 +0,0 @@
-{#
-  Python __init__.py Template
-  ===========================
-  Renders the __init__.py file that exports all types.
-
-  Expected context (PythonInitContext):
-    - baseTypes: TypeNode[] - Types without a parent for imports
-    - types: TypeNode[] - All types for __all__ export
-#}
-##########################################
-# WARNING: This is an auto-generated file.
-# DO NOT EDIT THIS FILE DIRECTLY
-# ANY EDITS WILL BE LOST
-##########################################
-from ._context import LoadContext, SaveContext
-{%- for type in baseTypes %}
-{% if type.childTypes.length > 0 %}
-from ._{{ type.typeName.name }} import (
-  {{ type.typeName.name }}
-  {%- for child in type.childTypes %},
-  {{ child.typeName.name }}
-  {%- endfor %}
-)
-{% else %}
-from ._{{ type.typeName.name }} import {{ type.typeName.name }}
-{% endif %}
-{%- endfor %}
-
-__all__ = [
-    "LoadContext",
-    "SaveContext",
-    {%- for type in types %}
-    "{{ type.typeName.name }}",
-    {%- endfor %}
-]
diff --git a/schema/emitter/src/templates/python/test.py.njk b/schema/emitter/src/templates/python/test.py.njk
deleted file mode 100644
index 6894c596..00000000
--- a/schema/emitter/src/templates/python/test.py.njk
+++ /dev/null
@@ -1,115 +0,0 @@
-{#
-  Python Test Template
-  ====================
-  Renders pytest test file for a type.
-
-  Expected context (BaseTestContext):
-    - node: TypeNode
-    - isAbstract: boolean
-    - package: string
-    - examples: Array<{ json: string[], yaml: string[], validations: Array<{ key, value, delimiter, isOptional }> }>
-    - alternates: Array<{ title, scalarType, value, validations: Array<{ key, value, delimiter, isOptional }> }>
-#}
-{%- if examples.length > 0 %}
-import json
-import yaml
-{% endif %}
-from {{ package }} import {{node.typeName.name}}
-
-{% for sample in examples %}
-def test_load_json_{{node.typeName.name | lower}}{% if not loop.first %}_{{loop.index - 1}}{% endif %}():
-    json_data = r'''
-    {% for line in sample.json -%}
-    {{ line }}
-    {% endfor -%}
-    '''
-    data = json.loads(json_data, strict=False)
-    instance = {{node.typeName.name}}.load(data)
-    assert instance is not None
-    {% for validation in sample.validations -%}
-    {%- if validation.value == "True" or validation.value == "False" %}
-    assert {% if validation.value == "False" %}not {% endif %}instance.{{ validation.key }}
-    {% else -%}
-    assert instance.{{ validation.key }} == {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }}
-    {% endif -%}
-    {% endfor %}
-
-def test_load_yaml_{{node.typeName.name | lower}}{% if not loop.first %}_{{loop.index - 1}}{% endif %}():
-    yaml_data = r'''
-    {% for line in sample.yaml -%}
-    {{ line }}
-    {% endfor -%}
-    '''
-    data = yaml.load(yaml_data, Loader=yaml.FullLoader)
-    instance = {{node.typeName.name}}.load(data)
-    assert instance is not None
-    {%- for validation in sample.validations %}
-    {%- if validation.value == "True" or validation.value == "False" %}
-    assert {% if validation.value == "False" %}not {% endif %}instance.{{ validation.key }}
-    {%- else %}
-    assert instance.{{ validation.key }} == {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }}
-    {%- endif %}
-    {%- endfor %}
-
-def test_roundtrip_json_{{node.typeName.name | lower}}{% if not loop.first %}_{{loop.index - 1}}{% endif %}():
-    """Test that load -> save -> load produces equivalent data."""
-    json_data = r'''
-    {% for line in sample.json -%}
-    {{ line }}
-    {% endfor -%}
-    '''
-    original_data = json.loads(json_data, strict=False)
-    instance = {{node.typeName.name}}.load(original_data)
-    saved_data = instance.save()
-    reloaded = {{node.typeName.name}}.load(saved_data)
-    assert reloaded is not None
-    {%- for validation in sample.validations %}
-    {%- if validation.value == "True" or validation.value == "False" %}
-    assert {% if validation.value == "False" %}not {% endif %}reloaded.{{ validation.key }}
-    {%- else %}
-    assert reloaded.{{ validation.key }} == {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }}
-    {%- endif %}
-    {%- endfor %}
-
-def test_to_json_{{node.typeName.name | lower}}{% if not loop.first %}_{{loop.index - 1}}{% endif %}():
-    """Test that to_json produces valid JSON."""
-    json_data = r'''
-    {% for line in sample.json -%}
-    {{ line }}
-    {% endfor -%}
-    '''
-    data = json.loads(json_data, strict=False)
-    instance = {{node.typeName.name}}.load(data)
-    json_output = instance.to_json()
-    assert json_output is not None
-    parsed = json.loads(json_output)
-    assert isinstance(parsed, dict)
-
-def test_to_yaml_{{node.typeName.name | lower}}{% if not loop.first %}_{{loop.index - 1}}{% endif %}():
-    """Test that to_yaml produces valid YAML."""
-    json_data = r'''
-    {% for line in sample.json -%}
-    {{ line }}
-    {% endfor -%}
-    '''
-    data = json.loads(json_data, strict=False)
-    instance = {{node.typeName.name}}.load(data)
-    yaml_output = instance.to_yaml()
-    assert yaml_output is not None
-    parsed = yaml.safe_load(yaml_output)
-    assert isinstance(parsed, dict)
-{% endfor %}
-{% if alternates.length > 0 %}
-{% for alt in alternates -%}
-def test_load_{{node.typeName.name | lower}}_from_{{ alt.scalarType }}():
-    instance = {{node.typeName.name}}.load({{ alt.value }})
-    assert instance is not None
-    {%- for item in alt.validations %}
-    {%- if item.value == "True" or item.value == "False" %}
-    assert {% if item.value == "False" %}not {% endif %}instance.{{ item.key }}
-    {%- else %}
-    assert instance.{{ item.key }} == {{ item.delimiter }}{{ item.value }}{{ item.delimiter }}
-    {%- endif %}
-    {%- endfor %}
-{% endfor %}
-{% endif %}
diff --git a/schema/emitter/src/templates/python/test_context.py.njk b/schema/emitter/src/templates/python/test_context.py.njk
deleted file mode 100644
index 5096e718..00000000
--- a/schema/emitter/src/templates/python/test_context.py.njk
+++ /dev/null
@@ -1,192 +0,0 @@
-{# Template for generating LoadContext and SaveContext tests #}
-{% from "macros.njk" import fileHeader %}
-{{ fileHeader(header) }}
-from {{ package }}._context import LoadContext, SaveContext
-
-
-class TestLoadContext:
-    """Tests for LoadContext class."""
-
-    def test_default_values(self) -> None:
-        """Test that LoadContext has correct default values."""
-        context = LoadContext()
-        assert context.pre_process is None
-        assert context.post_process is None
-
-    def test_process_input_without_callback(self) -> None:
-        """Test process_input returns original data when no callback set."""
-        context = LoadContext()
-        data = {"key": "value", "nested": {"a": 1}}
-        result = context.process_input(data)
-        assert result is data
-
-    def test_process_input_with_callback(self) -> None:
-        """Test process_input applies the pre_process callback."""
-        def add_field(data: dict) -> dict:
-            return {**data, "added": True}
-
-        context = LoadContext(pre_process=add_field)
-        data = {"key": "value"}
-        result = context.process_input(data)
-        assert result == {"key": "value", "added": True}
-        assert result is not data
-
-    def test_process_output_without_callback(self) -> None:
-        """Test process_output returns original result when no callback set."""
-        context = LoadContext()
-        result = {"some": "result"}
-        processed = context.process_output(result)
-        assert processed is result
-
-    def test_process_output_with_callback(self) -> None:
-        """Test process_output applies the post_process callback."""
-        def wrap_result(result: dict) -> dict:
-            return {"wrapped": result}
-
-        context = LoadContext(post_process=wrap_result)
-        result = {"key": "value"}
-        processed = context.process_output(result)
-        assert processed == {"wrapped": {"key": "value"}}
-
-    def test_both_callbacks(self) -> None:
-        """Test using both pre_process and post_process callbacks."""
-        def normalize_keys(data: dict) -> dict:
-            return {k.lower(): v for k, v in data.items()}
-
-        def add_metadata(result: dict) -> dict:
-            return {**result, "_processed": True}
-
-        context = LoadContext(pre_process=normalize_keys, post_process=add_metadata)
-
-        input_data = {"Key": "value", "UPPER": "case"}
-        processed_input = context.process_input(input_data)
-        assert processed_input == {"key": "value", "upper": "case"}
-
-        final_result = context.process_output(processed_input)
-        assert final_result == {"key": "value", "upper": "case", "_processed": True}
-
-    def test_pre_process_can_modify_structure(self) -> None:
-        """Test that pre_process can fundamentally transform data structure."""
-        def flatten_nested(data: dict) -> dict:
-            result = {}
-            for key, value in data.items():
-                if isinstance(value, dict):
-                    for nested_key, nested_value in value.items():
-                        result[f"{key}_{nested_key}"] = nested_value
-                else:
-                    result[key] = value
-            return result
-
-        context = LoadContext(pre_process=flatten_nested)
-        data = {"top": "level", "nested": {"a": 1, "b": 2}}
-        result = context.process_input(data)
-        assert result == {"top": "level", "nested_a": 1, "nested_b": 2}
-
-
-class TestSaveContext:
-    """Tests for SaveContext class."""
-
-    def test_default_values(self) -> None:
-        """Test that SaveContext has correct default values."""
-        context = SaveContext()
-        assert context.pre_save is None
-        assert context.post_save is None
-
-    def test_process_object_without_callback(self) -> None:
-        """Test process_object returns original object when no callback set."""
-        context = SaveContext()
-        obj = {"key": "value"}
-        result = context.process_object(obj)
-        assert result is obj
-
-    def test_process_object_with_callback(self) -> None:
-        """Test process_object applies the pre_save callback."""
-        def add_timestamp(obj: dict) -> dict:
-            return {**obj, "timestamp": "2024-01-01"}
-
-        context = SaveContext(pre_save=add_timestamp)
-        obj = {"key": "value"}
-        result = context.process_object(obj)
-        assert result == {"key": "value", "timestamp": "2024-01-01"}
-
-    def test_process_dict_without_callback(self) -> None:
-        """Test process_dict returns original dict when no callback set."""
-        context = SaveContext()
-        data = {"key": "value"}
-        result = context.process_dict(data)
-        assert result is data
-
-    def test_process_dict_with_callback(self) -> None:
-        """Test process_dict applies the post_save callback."""
-        def remove_internal_fields(data: dict) -> dict:
-            return {k: v for k, v in data.items() if not k.startswith("_")}
-
-        context = SaveContext(post_save=remove_internal_fields)
-        data = {"key": "value", "_internal": "secret"}
-        result = context.process_dict(data)
-        assert result == {"key": "value"}
-
-    def test_both_callbacks(self) -> None:
-        """Test using both pre_save and post_save callbacks."""
-        def mark_for_export(obj: dict) -> dict:
-            return {**obj, "_exporting": True}
-
-        def clean_markers(data: dict) -> dict:
-            return {k: v for k, v in data.items() if not k.startswith("_")}
-
-        context = SaveContext(pre_save=mark_for_export, post_save=clean_markers)
-
-        obj = {"name": "test", "value": 42}
-        processed_obj = context.process_object(obj)
-        assert processed_obj == {"name": "test", "value": 42, "_exporting": True}
-
-        final_dict = context.process_dict(processed_obj)
-        assert final_dict == {"name": "test", "value": 42}
-
-    def test_to_yaml(self) -> None:
-        """Test to_yaml produces valid YAML string."""
-        context = SaveContext()
-        data = {"name": "test", "items": ["a", "b"]}
-        result = context.to_yaml(data)
-        assert "name: test" in result
-        assert "items:" in result
-        assert "- a" in result
-        assert "- b" in result
-
-    def test_to_json(self) -> None:
-        """Test to_json produces valid JSON string."""
-        import json
-        context = SaveContext()
-        data = {"name": "test", "items": ["a", "b"]}
-        result = context.to_json(data)
-        parsed = json.loads(result)
-        assert parsed == data
-
-    def test_to_json_custom_indent(self) -> None:
-        """Test to_json respects custom indent."""
-        context = SaveContext()
-        data = {"name": "test"}
-        result_2 = context.to_json(data, indent=2)
-        result_4 = context.to_json(data, indent=4)
-        # 4-space indent should have more characters
-        assert len(result_4) > len(result_2)
-
-    def test_collection_format_default(self) -> None:
-        """Test that default collection_format is 'object'."""
-        context = SaveContext()
-        assert context.collection_format == "object"
-
-    def test_collection_format_array(self) -> None:
-        """Test collection_format can be set to 'array'."""
-        context = SaveContext(collection_format="array")
-        assert context.collection_format == "array"
-
-    def test_use_shorthand_default(self) -> None:
-        """Test that default use_shorthand is True."""
-        context = SaveContext()
-        assert context.use_shorthand is True
-
-    def test_use_shorthand_disabled(self) -> None:
-        """Test use_shorthand can be disabled."""
-        context = SaveContext(use_shorthand=False)
-        assert context.use_shorthand is False
diff --git a/schema/emitter/src/templates/rust/_macros.njk b/schema/emitter/src/templates/rust/_macros.njk
deleted file mode 100644
index 7bddb4ab..00000000
--- a/schema/emitter/src/templates/rust/_macros.njk
+++ /dev/null
@@ -1,529 +0,0 @@
-{#
-  Rust-Specific Macros for AgentSchema Emitter
-  =============================================
-
-  Usage in Rust templates:
-    {% import "_macros.njk" as rust %}
-    {{ rust.rustType(prop, typeMapper, polymorphicTypeNames) }}
-#}
-
-{% from "macros.njk" import separator, firstOrDefault %}
-
-
-{#
-  Render Rust type for a property.
-  - Dict fields -> serde_json::Value
-  - Non-scalar collection fields -> serde_json::Value (can be array OR dict in JSON)
-  - Scalar collections -> Vec<T> or Option<Vec<T>> if optional
-  - Polymorphic fields -> serde_json::Value (never Optional, Null represents absence)
-  - Optional non-polymorphic non-Value fields -> Option<T>
-  - Required fields -> T
-#}
-{% macro rustType(prop, typeMapper, polymorphicTypeNames) -%}
-{%- set baseType = typeMapper[prop.typeName.name] if prop.isScalar else (typeMapper[prop.typeName.name] or prop.typeName.name) -%}
-{%- if not baseType -%}{%- set baseType = "serde_json::Value" -%}{%- endif -%}
-{%- if prop.isDict -%}
-serde_json::Value
-{%- elif prop.isCollection and not prop.isScalar -%}
-serde_json::Value
-{%- elif prop.isCollection and prop.isScalar -%}
-{%- if prop.isOptional -%}
-Option<Vec<{{ typeMapper[prop.typeName.name] or "serde_json::Value" }}>>
-{%- else -%}
-Vec<{{ typeMapper[prop.typeName.name] or "serde_json::Value" }}>
-{%- endif -%}
-{%- elif prop.typeName.name in polymorphicTypeNames -%}
-serde_json::Value
-{%- elif prop.isOptional -%}
-Option<{{ baseType }}>
-{%- else -%}
-{{ baseType }}
-{%- endif -%}
-{%- endmacro %}
-
-
-{#
-  Render the default value for a Rust field.
-  NOTE: polymorphicTypeNames must be passed so we can default serde_json::Value fields to Null.
-#}
-{% macro defaultValue(prop, typeMapper, polymorphicTypeNames) -%}
-{%- if prop.isDict -%}
-serde_json::Value::Null
-{%- elif prop.isCollection and not prop.isScalar -%}
-serde_json::Value::Null
-{%- elif prop.isCollection and prop.isScalar -%}
-{%- if prop.isOptional -%}
-None
-{%- else -%}
-Vec::new()
-{%- endif -%}
-{%- elif prop.typeName.name in polymorphicTypeNames -%}
-serde_json::Value::Null
-{%- elif prop.isOptional -%}
-None
-{%- elif prop.isScalar -%}
-{%- if prop.typeName.name == "boolean" -%}
-{{ "true" if prop.defaultValue else "false" }}
-{%- elif prop.typeName.name == "string" -%}
-String::from("{{ prop.defaultValue if prop.defaultValue else "" }}")
-{%- elif prop.typeName.name in ["int32", "int64", "integer", "float", "float32", "float64", "number", "numeric"] -%}
-0
-{%- else -%}
-Default::default()
-{%- endif -%}
-{%- else -%}
-Default::default()
-{%- endif -%}
-{%- endmacro %}
-
-
-{#
-  Render load code for a single property.
-  Polymorphic fields are always serde_json::Value (never Option-wrapped).
-  Optional non-polymorphic non-scalar fields are wrapped in Some().
-#}
-{% macro loadProperty(prop, varName, typeMapper, polymorphicTypeNames) -%}
-{%- set propNameRust = prop.name | snakeCase -%}
-{%- if prop.isCollection and not prop.isDict and not prop.isScalar %}
-        if let Some(val) = {{ varName }}.get("{{ prop.name }}") {
-            result.{{ propNameRust }} = val.clone();
-        }
-{%- elif prop.isCollection and not prop.isDict and prop.isScalar %}
-        if let Some(arr) = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()) {
-{%- if prop.typeName.name == "string" %}
-{%- if prop.isOptional %}
-            result.{{ propNameRust }} = Some(arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect());
-{%- else %}
-            result.{{ propNameRust }} = arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect();
-{%- endif %}
-{%- elif prop.typeName.name == "boolean" %}
-{%- if prop.isOptional %}
-            result.{{ propNameRust }} = Some(arr.iter().filter_map(|v| v.as_bool()).collect());
-{%- else %}
-            result.{{ propNameRust }} = arr.iter().filter_map(|v| v.as_bool()).collect();
-{%- endif %}
-{%- elif prop.typeName.name == "int32" %}
-{%- if prop.isOptional %}
-            result.{{ propNameRust }} = Some(arr.iter().filter_map(|v| v.as_i64().map(|n| n as i32)).collect());
-{%- else %}
-            result.{{ propNameRust }} = arr.iter().filter_map(|v| v.as_i64().map(|n| n as i32)).collect();
-{%- endif %}
-{%- elif prop.typeName.name in ["int64", "integer"] %}
-{%- if prop.isOptional %}
-            result.{{ propNameRust }} = Some(arr.iter().filter_map(|v| v.as_i64()).collect());
-{%- else %}
-            result.{{ propNameRust }} = arr.iter().filter_map(|v| v.as_i64()).collect();
-{%- endif %}
-{%- elif prop.typeName.name == "float32" %}
-{%- if prop.isOptional %}
-            result.{{ propNameRust }} = Some(arr.iter().filter_map(|v| v.as_f64().map(|n| n as f32)).collect());
-{%- else %}
-            result.{{ propNameRust }} = arr.iter().filter_map(|v| v.as_f64().map(|n| n as f32)).collect();
-{%- endif %}
-{%- elif prop.typeName.name in ["float64", "number", "float", "numeric"] %}
-{%- if prop.isOptional %}
-            result.{{ propNameRust }} = Some(arr.iter().filter_map(|v| v.as_f64()).collect());
-{%- else %}
-            result.{{ propNameRust }} = arr.iter().filter_map(|v| v.as_f64()).collect();
-{%- endif %}
-{%- else %}
-{# generic/any/unknown type - clone the serde_json::Value elements #}
-{%- if prop.isOptional %}
-            result.{{ propNameRust }} = Some(arr.iter().cloned().collect());
-{%- else %}
-            result.{{ propNameRust }} = arr.iter().cloned().collect();
-{%- endif %}
-{%- endif %}
-        }
-{%- elif prop.isDict %}
-        if let Some(val) = {{ varName }}.get("{{ prop.name }}") {
-            result.{{ propNameRust }} = val.clone();
-        }
-{%- elif prop.isScalar %}
-{%- if prop.typeName.name == "string" %}
-{%- if prop.isOptional %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_str()).map(|s| s.to_string());
-{%- else %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_str()).unwrap_or_default().to_string();
-{%- endif %}
-{%- elif prop.typeName.name == "boolean" %}
-{%- if prop.isOptional %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_bool());
-{%- else %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_bool()).unwrap_or({{ "true" if prop.defaultValue else "false" }});
-{%- endif %}
-{%- elif prop.typeName.name == "int32" %}
-{%- if prop.isOptional %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_i64()).map(|n| n as i32);
-{%- else %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_i64()).unwrap_or(0) as i32;
-{%- endif %}
-{%- elif prop.typeName.name in ["int64", "integer"] %}
-{%- if prop.isOptional %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_i64());
-{%- else %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_i64()).unwrap_or(0);
-{%- endif %}
-{%- elif prop.typeName.name == "float32" %}
-{%- if prop.isOptional %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_f64()).map(|n| n as f32);
-{%- else %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32;
-{%- endif %}
-{%- elif prop.typeName.name in ["float64", "number", "float", "numeric"] %}
-{%- if prop.isOptional %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_f64());
-{%- else %}
-        result.{{ propNameRust }} = {{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_f64()).unwrap_or(0.0);
-{%- endif %}
-{%- else %}
-{# any/unknown scalar type - use serde_json::Value #}
-        if let Some(val) = {{ varName }}.get("{{ prop.name }}") {
-{%- if prop.isOptional %}
-            result.{{ propNameRust }} = Some(val.clone());
-{%- else %}
-            result.{{ propNameRust }} = val.clone();
-{%- endif %}
-        }
-{%- endif %}
-{%- else %}
-{%- if prop.typeName.name in polymorphicTypeNames %}
-{# Polymorphic: type is serde_json::Value, never use Option wrapping #}
-        if let Some(val) = {{ varName }}.get("{{ prop.name }}") {
-            result.{{ propNameRust }} = val.clone();
-        }
-{%- else %}
-{# Non-scalar, non-polymorphic: load from nested object #}
-        if let Some(val) = {{ varName }}.get("{{ prop.name }}") {
-            if val.is_object() || val.is_array() {
-{%- if prop.isOptional %}
-                result.{{ propNameRust }} = Some({{ prop.typeName.name }}::load_from_value(val, ctx));
-{%- else %}
-                result.{{ propNameRust }} = {{ prop.typeName.name }}::load_from_value(val, ctx);
-{%- endif %}
-            }
-        }
-{%- endif %}
-{%- endif %}
-{%- endmacro %}
-
-
-{#
-  Render save code for a single property.
-#}
-{% macro saveProperty(prop, polymorphicTypeNames) -%}
-{%- set propNameRust = prop.name | snakeCase -%}
-{%- if prop.isCollection and not prop.isDict and not prop.isScalar %}
-        if !self.{{ propNameRust }}.is_null() {
-            result.insert("{{ prop.name }}".to_string(), self.{{ propNameRust }}.clone());
-        }
-{%- elif prop.isCollection and not prop.isDict and prop.isScalar %}
-{%- if prop.isOptional %}
-        if let Some(ref items) = self.{{ propNameRust }} {
-            result.insert("{{ prop.name }}".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
-        }
-{%- else %}
-        if !self.{{ propNameRust }}.is_empty() {
-            result.insert("{{ prop.name }}".to_string(), serde_json::to_value(&self.{{ propNameRust }}).unwrap_or(serde_json::Value::Null));
-        }
-{%- endif %}
-{%- elif prop.isDict %}
-        if !self.{{ propNameRust }}.is_null() {
-            result.insert("{{ prop.name }}".to_string(), self.{{ propNameRust }}.clone());
-        }
-{%- elif prop.isScalar %}
-{%- if prop.typeName.name == "string" %}
-{%- if prop.isOptional %}
-        if let Some(ref val) = self.{{ propNameRust }} {
-            result.insert("{{ prop.name }}".to_string(), serde_json::Value::String(val.clone()));
-        }
-{%- else %}
-        if !self.{{ propNameRust }}.is_empty() {
-            result.insert("{{ prop.name }}".to_string(), serde_json::Value::String(self.{{ propNameRust }}.clone()));
-        }
-{%- endif %}
-{%- elif prop.typeName.name == "boolean" %}
-{%- if prop.isOptional %}
-        if let Some(val) = self.{{ propNameRust }} {
-            result.insert("{{ prop.name }}".to_string(), serde_json::Value::Bool(val));
-        }
-{%- else %}
-        result.insert("{{ prop.name }}".to_string(), serde_json::Value::Bool(self.{{ propNameRust }}));
-{%- endif %}
-{%- else %}
-{%- if prop.isOptional %}
-        if let Some(ref val) = self.{{ propNameRust }} {
-            result.insert("{{ prop.name }}".to_string(), serde_json::to_value(val).unwrap_or(serde_json::Value::Null));
-        }
-{%- else %}
-        result.insert("{{ prop.name }}".to_string(), serde_json::to_value(self.{{ propNameRust }}).unwrap_or(serde_json::Value::Null));
-{%- endif %}
-{%- endif %}
-{%- else %}
-{%- if prop.typeName.name in polymorphicTypeNames %}
-{# Polymorphic: type is serde_json::Value, check is_null() #}
-        if !self.{{ propNameRust }}.is_null() {
-            result.insert("{{ prop.name }}".to_string(), self.{{ propNameRust }}.clone());
-        }
-{%- else %}
-{# Non-scalar, non-polymorphic #}
-{%- if prop.isOptional %}
-        if let Some(ref val) = self.{{ propNameRust }} {
-            let nested = val.to_value(ctx);
-            if !nested.is_null() {
-                result.insert("{{ prop.name }}".to_string(), nested);
-            }
-        }
-{%- else %}
-        {
-            let nested = self.{{ propNameRust }}.to_value(ctx);
-            if !nested.is_null() {
-                result.insert("{{ prop.name }}".to_string(), nested);
-            }
-        }
-{%- endif %}
-{%- endif %}
-{%- endif %}
-{%- endmacro %}
-
-
-{#
-  Render save code for a variant field (bound by reference from a match arm).
-  Like saveProperty but uses bare variable names instead of self.field,
-  since variant fields are already references from the match pattern.
-#}
-{% macro saveVariantField(prop, polymorphicTypeNames) -%}
-{%- set propNameRust = prop.name | snakeCase -%}
-{%- if prop.isCollection and not prop.isDict and not prop.isScalar %}
-        if !{{ propNameRust }}.is_null() {
-            result.insert("{{ prop.name }}".to_string(), {{ propNameRust }}.clone());
-        }
-{%- elif prop.isCollection and not prop.isDict and prop.isScalar %}
-{%- if prop.isOptional %}
-        if let Some(items) = {{ propNameRust }} {
-            result.insert("{{ prop.name }}".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));
-        }
-{%- else %}
-        if !{{ propNameRust }}.is_empty() {
-            result.insert("{{ prop.name }}".to_string(), serde_json::to_value({{ propNameRust }}).unwrap_or(serde_json::Value::Null));
-        }
-{%- endif %}
-{%- elif prop.isDict %}
-        if !{{ propNameRust }}.is_null() {
-            result.insert("{{ prop.name }}".to_string(), {{ propNameRust }}.clone());
-        }
-{%- elif prop.isScalar %}
-{%- if prop.typeName.name == "string" %}
-{%- if prop.isOptional %}
-        if let Some(val) = {{ propNameRust }} {
-            result.insert("{{ prop.name }}".to_string(), serde_json::Value::String(val.clone()));
-        }
-{%- else %}
-        if !{{ propNameRust }}.is_empty() {
-            result.insert("{{ prop.name }}".to_string(), serde_json::Value::String({{ propNameRust }}.clone()));
-        }
-{%- endif %}
-{%- elif prop.typeName.name == "boolean" %}
-{%- if prop.isOptional %}
-        if let Some(val) = {{ propNameRust }} {
-            result.insert("{{ prop.name }}".to_string(), serde_json::Value::Bool(*val));
-        }
-{%- else %}
-        result.insert("{{ prop.name }}".to_string(), serde_json::Value::Bool(*{{ propNameRust }}));
-{%- endif %}
-{%- else %}
-{%- if prop.isOptional %}
-        if let Some(val) = {{ propNameRust }} {
-            result.insert("{{ prop.name }}".to_string(), serde_json::to_value(val).unwrap_or(serde_json::Value::Null));
-        }
-{%- else %}
-        result.insert("{{ prop.name }}".to_string(), serde_json::to_value({{ propNameRust }}).unwrap_or(serde_json::Value::Null));
-{%- endif %}
-{%- endif %}
-{%- else %}
-{%- if prop.typeName.name in polymorphicTypeNames %}
-        if !{{ propNameRust }}.is_null() {
-            result.insert("{{ prop.name }}".to_string(), {{ propNameRust }}.clone());
-        }
-{%- else %}
-{%- if prop.isOptional %}
-        if let Some(val) = {{ propNameRust }} {
-            let nested = val.to_value(ctx);
-            if !nested.is_null() {
-                result.insert("{{ prop.name }}".to_string(), nested);
-            }
-        }
-{%- else %}
-        {
-            let nested = {{ propNameRust }}.to_value(ctx);
-            if !nested.is_null() {
-                result.insert("{{ prop.name }}".to_string(), nested);
-            }
-        }
-{%- endif %}
-{%- endif %}
-{%- endif %}
-{%- endmacro %}
-
-
-{#
-  Generate a typed accessor method for a non-scalar collection or dict field.
-  Non-scalar collection fields are stored as serde_json::Value (can be array OR dict in JSON).
-  This accessor parses them into typed Vec<T>.
-#}
-{% macro typedAccessor(prop) -%}
-{%- set propNameRust = prop.name | snakeCase -%}
-{%- if prop.isCollection and not prop.isScalar and not prop.isDict %}
-    /// Returns typed `Vec<{{ prop.typeName.name }}>` by parsing the stored JSON value.
-    /// Handles both array format `[{...}]` and dict format `{"name": {...}}`.
-    /// Returns `None` if the field is null or cannot be parsed.
-    pub fn as_{{ propNameRust }}(&self) -> Option<Vec<{{ prop.typeName.name }}>> {
-        match &self.{{ propNameRust }} {
-            serde_json::Value::Array(arr) => {
-                Some(arr.iter().map(|v| {{ prop.typeName.name }}::load_from_value(v, &LoadContext::default())).collect())
-            }
-            serde_json::Value::Object(obj) => {
-                let result: Vec<{{ prop.typeName.name }}> = obj
-                    .iter()
-                    .filter_map(|(name, value)| {
-                        if value.is_array() {
-                            // Invalid format: skip entries with array values.
-                            // '{{ prop.name }}' must be a flat list or name-keyed dict.
-                            return None;
-                        }
-                        let mut v = if value.is_object() {
-                            value.clone()
-                        } else {
-                            serde_json::json!({ "value": value })
-                        };
-                        if let serde_json::Value::Object(ref mut m) = v {
-                            m.entry("name".to_string()).or_insert_with(|| serde_json::Value::String(name.clone()));
-                        }
-                        Some({{ prop.typeName.name }}::load_from_value(&v, &LoadContext::default()))
-                    })
-                    .collect();
-                Some(result)
-            }
-            _ => None,
-        }
-    }
-{%- elif prop.isDict %}
-    /// Returns typed reference to the map if the field is an object.
-    /// Returns `None` if the field is null or not an object.
-    pub fn as_{{ propNameRust }}_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {
-        self.{{ propNameRust }}.as_object()
-    }
-{%- endif -%}
-{%- endmacro %}
-
-
-{#
-  Render an expression that initializes a field from a JSON value.
-  Used for struct initialization syntax to avoid clippy::field_reassign_with_default.
-#}
-{% macro fieldInitializer(prop, varName, typeMapper, polymorphicTypeNames) -%}
-{%- set propNameRust = prop.name | snakeCase -%}
-{%- if prop.isCollection and not prop.isDict and not prop.isScalar %}
-{{ varName }}.get("{{ prop.name }}").cloned().unwrap_or(serde_json::Value::Null)
-{%- elif prop.isCollection and not prop.isDict and prop.isScalar %}
-{%- if prop.typeName.name == "string" %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()).unwrap_or_default()
-{%- endif %}
-{%- elif prop.typeName.name == "boolean" %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_bool()).collect())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_bool()).collect()).unwrap_or_default()
-{%- endif %}
-{%- elif prop.typeName.name == "int32" %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_i64().map(|n| n as i32)).collect())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_i64().map(|n| n as i32)).collect()).unwrap_or_default()
-{%- endif %}
-{%- elif prop.typeName.name in ["int64", "integer"] %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_i64()).collect())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_i64()).collect()).unwrap_or_default()
-{%- endif %}
-{%- elif prop.typeName.name == "float32" %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_f64().map(|n| n as f32)).collect())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_f64().map(|n| n as f32)).collect()).unwrap_or_default()
-{%- endif %}
-{%- elif prop.typeName.name in ["float64", "number", "float", "numeric"] %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_f64()).collect())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_f64()).collect()).unwrap_or_default()
-{%- endif %}
-{%- else %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.to_vec())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_array()).map(|arr| arr.to_vec()).unwrap_or_default()
-{%- endif %}
-{%- endif %}
-{%- elif prop.isDict %}
-{{ varName }}.get("{{ prop.name }}").cloned().unwrap_or(serde_json::Value::Null)
-{%- elif prop.isScalar %}
-{%- if prop.typeName.name == "string" %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_str()).map(|s| s.to_string())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_str()).unwrap_or_default().to_string()
-{%- endif %}
-{%- elif prop.typeName.name == "boolean" %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_bool())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_bool()).unwrap_or({{ "true" if prop.defaultValue else "false" }})
-{%- endif %}
-{%- elif prop.typeName.name == "int32" %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_i64()).map(|n| n as i32)
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_i64()).unwrap_or(0) as i32
-{%- endif %}
-{%- elif prop.typeName.name in ["int64", "integer"] %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_i64())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_i64()).unwrap_or(0)
-{%- endif %}
-{%- elif prop.typeName.name == "float32" %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_f64()).map(|n| n as f32)
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32
-{%- endif %}
-{%- elif prop.typeName.name in ["float64", "number", "float", "numeric"] %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_f64())
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").and_then(|v| v.as_f64()).unwrap_or(0.0)
-{%- endif %}
-{%- else %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").cloned()
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").cloned().unwrap_or(serde_json::Value::Null)
-{%- endif %}
-{%- endif %}
-{%- else %}
-{%- if prop.typeName.name in polymorphicTypeNames %}
-{{ varName }}.get("{{ prop.name }}").cloned().unwrap_or(serde_json::Value::Null)
-{%- else %}
-{%- if prop.isOptional %}
-{{ varName }}.get("{{ prop.name }}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| {{ prop.typeName.name }}::load_from_value(v, ctx))
-{%- else %}
-{{ varName }}.get("{{ prop.name }}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| {{ prop.typeName.name }}::load_from_value(v, ctx)).unwrap_or_default()
-{%- endif %}
-{%- endif %}
-{%- endif %}
-{%- endmacro %}
diff --git a/schema/emitter/src/templates/rust/context.rs.njk b/schema/emitter/src/templates/rust/context.rs.njk
deleted file mode 100644
index a76e0880..00000000
--- a/schema/emitter/src/templates/rust/context.rs.njk
+++ /dev/null
@@ -1,178 +0,0 @@
-{#
-  Rust Context Template
-  =====================
-  Renders LoadContext and SaveContext utilities.
-
-  Expected context (RustContextContext):
-    - header: string
-#}
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-// {{ header }}
-
-/// Callback type for pre-processing input data before parsing.
-pub type PreProcessFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
-
-/// Callback type for post-processing the result after instantiation.
-pub type PostProcessFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
-
-/// Callback type for pre-processing an object before serialization.
-pub type PreSaveFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
-
-/// Callback type for post-processing a dictionary after serialization.
-pub type PostSaveFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
-
-/// Context for customizing the loading process of agent definitions.
-///
-/// Provides hooks for pre-processing input data before parsing and
-/// post-processing output data after instantiation.
-pub struct LoadContext {
-    /// Optional callback to transform input data before parsing.
-    pub pre_process: Option<PreProcessFn>,
-    /// Optional callback to transform the result after instantiation.
-    pub post_process: Option<PostProcessFn>,
-}
-
-impl std::fmt::Debug for LoadContext {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("LoadContext")
-            .field("pre_process", &self.pre_process.as_ref().map(|_| "..."))
-            .field("post_process", &self.post_process.as_ref().map(|_| "..."))
-            .finish()
-    }
-}
-
-impl Default for LoadContext {
-    fn default() -> Self {
-        Self {
-            pre_process: None,
-            post_process: None,
-        }
-    }
-}
-
-impl LoadContext {
-    /// Create a new empty LoadContext.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Apply pre-processing to input data if a pre_process callback is set.
-    ///
-    /// # Arguments
-    /// * `data` - The raw input value to process.
-    ///
-    /// # Returns
-    /// The processed value, or the original if no callback is set.
-    pub fn process_input(&self, data: serde_json::Value) -> serde_json::Value {
-        if let Some(ref f) = self.pre_process {
-            f(data)
-        } else {
-            data
-        }
-    }
-
-    /// Apply post-processing to the result if a post_process callback is set.
-    ///
-    /// # Arguments
-    /// * `result` - The instantiated value to process.
-    ///
-    /// # Returns
-    /// The processed result, or the original if no callback is set.
-    pub fn process_output(&self, result: serde_json::Value) -> serde_json::Value {
-        if let Some(ref f) = self.post_process {
-            f(result)
-        } else {
-            result
-        }
-    }
-}
-
-/// Context for customizing the serialization process of agent definitions.
-///
-/// Provides hooks for pre-processing the object before serialization and
-/// post-processing the dictionary after serialization.
-pub struct SaveContext {
-    /// Optional callback to transform the object before serialization.
-    pub pre_save: Option<PreSaveFn>,
-    /// Optional callback to transform the dictionary after serialization.
-    pub post_save: Option<PostSaveFn>,
-    /// Output format for collections: "object" (name as key) or "array" (list of dicts).
-    /// Defaults to "object".
-    pub collection_format: String,
-    /// Use shorthand scalar representation when possible.
-    /// Defaults to true.
-    pub use_shorthand: bool,
-}
-
-impl std::fmt::Debug for SaveContext {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SaveContext")
-            .field("pre_save", &self.pre_save.as_ref().map(|_| "..."))
-            .field("post_save", &self.post_save.as_ref().map(|_| "..."))
-            .field("collection_format", &self.collection_format)
-            .field("use_shorthand", &self.use_shorthand)
-            .finish()
-    }
-}
-
-impl Default for SaveContext {
-    fn default() -> Self {
-        Self {
-            pre_save: None,
-            post_save: None,
-            collection_format: "object".to_string(),
-            use_shorthand: true,
-        }
-    }
-}
-
-impl SaveContext {
-    /// Create a new SaveContext with defaults.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Apply pre-processing to the object if a pre_save callback is set.
-    ///
-    /// # Arguments
-    /// * `obj` - The value to process before serialization.
-    ///
-    /// # Returns
-    /// The processed value, or the original if no callback is set.
-    pub fn process_object(&self, obj: serde_json::Value) -> serde_json::Value {
-        if let Some(ref f) = self.pre_save {
-            f(obj)
-        } else {
-            obj
-        }
-    }
-
-    /// Apply post-processing to the dictionary if a post_save callback is set.
-    ///
-    /// # Arguments
-    /// * `data` - The serialized value to process.
-    ///
-    /// # Returns
-    /// The processed value, or the original if no callback is set.
-    pub fn process_dict(&self, data: serde_json::Value) -> serde_json::Value {
-        if let Some(ref f) = self.post_save {
-            f(data)
-        } else {
-            data
-        }
-    }
-
-    /// Convert a value to a YAML string.
-    pub fn to_yaml(&self, data: &serde_json::Value) -> Result<String, serde_yaml::Error> {
-        serde_yaml::to_string(data)
-    }
-
-    /// Convert a value to a JSON string.
-    pub fn to_json(&self, data: &serde_json::Value, indent: bool) -> Result<String, serde_json::Error> {
-        if indent {
-            serde_json::to_string_pretty(data)
-        } else {
-            serde_json::to_string(data)
-        }
-    }
-}
diff --git a/schema/emitter/src/templates/rust/file.rs.njk b/schema/emitter/src/templates/rust/file.rs.njk
deleted file mode 100644
index 812d0a48..00000000
--- a/schema/emitter/src/templates/rust/file.rs.njk
+++ /dev/null
@@ -1,345 +0,0 @@
-{#
-  Rust Struct File Template
-  =========================
-  Renders Rust struct definitions with JSON/YAML serialization.
-  For polymorphic base types (types with childTypes + discriminator),
-  generates a base struct with shared fields + an enum with variant-specific
-  fields — the idiomatic Rust pattern for discriminated unions.
-
-  Expected context (RustFileContext):
-    - containsAbstract: boolean
-    - imports: string[]
-    - classes: RustClassContext[]
-    - typeMapper: Record<string, string>
-    - polymorphicTypeNames: string[]
-#}
-{% import "_macros.njk" as rust %}
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use super::context::{LoadContext, SaveContext};
-{% for import in imports %}
-use super::{{ import | snakeCase }}::{{ import }};
-{% endfor %}
-
-{% for class in classes %}
-{#- Skip polymorphic child types — they are represented as enum variants on the base -#}
-{%- if class.isPolymorphicChild %}
-{#- nothing -#}
-{#- ================================================================
-    POLYMORPHIC BASE TYPE — struct with shared fields + enum for variants
-    ================================================================ -#}
-{%- elif class.isPolymorphicBase %}
-
-/// Variant-specific data for [`{{ class.node.typeName.name }}`], discriminated by `{{ class.discriminatorField }}`.
-#[derive(Debug, Clone)]
-pub enum {{ class.enumName }} {
-{%- for variant in class.variants %}
-{%- if variant.isWildcard %}
-    /// Wildcard / catch-all variant for unrecognized `{{ class.discriminatorField }}` values.
-{%- else %}
-    /// `{{ class.discriminatorField }}` = `"{{ variant.kindValue }}"`
-{%- endif %}
-    {{ variant.variantName }}{% if variant.properties.length > 0 %} {
-{%- for prop in variant.properties %}
-{%- if prop.description %}
-        /// {{ prop.description | replace("\r\n", " ") | replace("\n", " ") | trim }}
-{%- endif %}
-        {{ prop.name | snakeCase }}: {{ rust.rustType(prop, typeMapper, polymorphicTypeNames) | trim }},
-{%- endfor %}
-{%- if variant.isWildcard %}
-        /// The raw `{{ class.discriminatorField }}` string for this unknown variant.
-        kind_name: String,
-{%- endif %}
-    }{% elif variant.isWildcard %} {
-        /// The raw `{{ class.discriminatorField }}` string for this unknown variant.
-        kind_name: String,
-    }{% endif %},
-{%- endfor %}
-}
-
-impl Default for {{ class.enumName }} {
-    fn default() -> Self {
-{%- for variant in class.variants %}
-{%- if variant.isWildcard %}
-        {{ class.enumName }}::{{ variant.variantName }} {
-{%- for prop in variant.properties %}
-            {{ prop.name | snakeCase }}: {{ rust.defaultValue(prop, typeMapper, polymorphicTypeNames) | trim }},
-{%- endfor %}
-            kind_name: String::new(),
-        }
-{%- endif %}
-{%- endfor %}
-{%- if not class.variants | selectattr("isWildcard") | list | length %}
-{%- for variant in class.variants %}
-{%- if loop.first %}
-        {{ class.enumName }}::{{ variant.variantName }}{% if variant.properties.length > 0 %} {
-{%- for prop in variant.properties %}
-            {{ prop.name | snakeCase }}: {{ rust.defaultValue(prop, typeMapper, polymorphicTypeNames) | trim }},
-{%- endfor %}
-        }{% endif %}
-{%- endif %}
-{%- endfor %}
-{%- endif %}
-    }
-}
-
-{%- if class.node.description %}
-/// {{ class.node.description | replace("\r\n", " ") | replace("\n", " ") | trim }}
-{%- else %}
-/// {{ class.node.typeName.name }} schema type
-{%- endif %}
-#[derive(Debug, Clone, Default)]
-pub struct {{ class.node.typeName.name }} {
-{%- for prop in class.basePropertiesWithoutDiscriminator %}
-{%- if prop.description %}
-    /// {{ prop.description | replace("\r\n", " ") | replace("\n", " ") | trim }}
-{%- endif %}
-    pub {{ prop.name | snakeCase }}: {{ rust.rustType(prop, typeMapper, polymorphicTypeNames) | trim }},
-{%- endfor %}
-    /// Variant-specific data, discriminated by `{{ class.discriminatorField }}`.
-    pub {{ class.discriminatorField | snakeCase }}: {{ class.enumName }},
-}
-
-impl {{ class.node.typeName.name }} {
-    /// Create a new {{ class.node.typeName.name }} with default values.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Load {{ class.node.typeName.name }} from a JSON string.
-    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
-        let value: serde_json::Value = serde_json::from_str(json)?;
-        Ok(Self::load_from_value(&value, ctx))
-    }
-
-    /// Load {{ class.node.typeName.name }} from a YAML string.
-    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
-        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
-        Ok(Self::load_from_value(&value, ctx))
-    }
-
-    /// Load {{ class.node.typeName.name }} from a `serde_json::Value`.
-    ///
-    /// Calls `ctx.process_input` before field extraction.
-    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
-        let value = ctx.process_input(value.clone());
-        {%- if class.alternates.length > 0 %}
-        {%- for alt in class.alternates %}
-        {%- if alt.scalar == "String" %}
-        if let Some(s) = value.as_str() {
-            let value = s.to_string();
-            let expansion = serde_json::json!({{ alt.alternate }});
-            return Self::load_from_value(&expansion, ctx);
-        }
-        {%- elif alt.scalar == "bool" %}
-        if let Some(value) = value.as_bool() {
-            let expansion = serde_json::json!({{ alt.alternate }});
-            return Self::load_from_value(&expansion, ctx);
-        }
-        {%- elif alt.scalar in ["i64", "i32"] %}
-        if let Some(value) = value.as_i64() {
-            let expansion = serde_json::json!({{ alt.alternate }});
-            return Self::load_from_value(&expansion, ctx);
-        }
-        {%- elif alt.scalar in ["f64", "f32"] %}
-        if let Some(value) = value.as_f64() {
-            let expansion = serde_json::json!({{ alt.alternate }});
-            return Self::load_from_value(&expansion, ctx);
-        }
-        {%- endif %}
-        {%- endfor %}
-        {%- endif %}
-        let {{ class.discriminatorField }}_str = value.get("{{ class.discriminatorField }}").and_then(|v| v.as_str()).unwrap_or("");
-        let {{ class.discriminatorField }} = match {{ class.discriminatorField }}_str {
-{%- for variant in class.variants %}
-{%- if not variant.isWildcard %}
-            "{{ variant.kindValue }}" => {{ class.enumName }}::{{ variant.variantName }}{% if variant.properties.length > 0 %} {
-{%- for prop in variant.properties %}
-                {{ prop.name | snakeCase }}: {{ rust.fieldInitializer(prop, "value", typeMapper, polymorphicTypeNames) | trim }},
-{%- endfor %}
-            }{% endif %},
-{%- endif %}
-{%- endfor %}
-{%- for variant in class.variants %}
-{%- if variant.isWildcard %}
-            _ => {{ class.enumName }}::{{ variant.variantName }} {
-{%- for prop in variant.properties %}
-                {{ prop.name | snakeCase }}: {{ rust.fieldInitializer(prop, "value", typeMapper, polymorphicTypeNames) | trim }},
-{%- endfor %}
-                kind_name: {{ class.discriminatorField }}_str.to_string(),
-            },
-{%- endif %}
-{%- endfor %}
-{%- if not class.variants | selectattr("isWildcard") | list | length %}
-            _ => {{ class.enumName }}::default(),
-{%- endif %}
-        };
-        Self {
-{%- for prop in class.basePropertiesWithoutDiscriminator %}
-            {{ prop.name | snakeCase }}: {{ rust.fieldInitializer(prop, "value", typeMapper, polymorphicTypeNames) | trim }},
-{%- endfor %}
-            {{ class.discriminatorField | snakeCase }}: {{ class.discriminatorField }},
-        }
-    }
-
-    /// Returns the `{{ class.discriminatorField }}` discriminator string for this instance.
-    pub fn {{ class.discriminatorField }}_str(&self) -> &str {
-        match &self.{{ class.discriminatorField | snakeCase }} {
-{%- for variant in class.variants %}
-{%- if variant.isWildcard %}
-            {{ class.enumName }}::{{ variant.variantName }} { kind_name, .. } => kind_name.as_str(),
-{%- else %}
-            {{ class.enumName }}::{{ variant.variantName }}{% if variant.properties.length > 0 %} { .. }{% endif %} => "{{ variant.kindValue }}",
-{%- endif %}
-{%- endfor %}
-        }
-    }
-
-    /// Serialize {{ class.node.typeName.name }} to a `serde_json::Value`.
-    ///
-    /// Calls `ctx.process_dict` after serialization.
-    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
-        let mut result = serde_json::Map::new();
-        // Write the discriminator
-        result.insert("{{ class.discriminatorField }}".to_string(), serde_json::Value::String(self.{{ class.discriminatorField }}_str().to_string()));
-        // Write base fields
-{%- for prop in class.basePropertiesWithoutDiscriminator %}
-        {{ rust.saveProperty(prop, polymorphicTypeNames) | trim }}
-{%- endfor %}
-        // Write variant-specific fields
-        match &self.{{ class.discriminatorField | snakeCase }} {
-{%- for variant in class.variants %}
-            {{ class.enumName }}::{{ variant.variantName }}{% if variant.properties.length > 0 or variant.isWildcard %} { {% for prop in variant.properties %}{{ prop.name | snakeCase }}, {% endfor %}{% if variant.isWildcard %}kind_name: _,{% endif %} .. }{% endif %} => {
-{%- for prop in variant.properties %}
-                {{ rust.saveVariantField(prop, polymorphicTypeNames) | trim }}
-{%- endfor %}
-            }
-{%- endfor %}
-        }
-        ctx.process_dict(serde_json::Value::Object(result))
-    }
-
-    /// Serialize {{ class.node.typeName.name }} to a JSON string.
-    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
-        serde_json::to_string_pretty(&self.to_value(ctx))
-    }
-
-    /// Serialize {{ class.node.typeName.name }} to a YAML string.
-    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
-        serde_yaml::to_string(&self.to_value(ctx))
-    }
-
-{%- for prop in class.basePropertiesWithoutDiscriminator %}
-{%- if (prop.isCollection and not prop.isScalar and not prop.isDict) or prop.isDict %}
-    {{ rust.typedAccessor(prop) | trim }}
-
-{%- endif %}
-{%- endfor %}
-}
-
-{#- ================================================================
-    NON-POLYMORPHIC TYPE — standard struct generation
-    ================================================================ -#}
-{%- else %}
-{%- if class.node.description %}
-/// {{ class.node.description | replace("\r\n", " ") | replace("\n", " ") | trim }}
-{%- else %}
-/// {{ class.node.typeName.name }} schema type
-{%- endif %}
-#[derive(Debug, Clone, Default)]
-pub struct {{ class.node.typeName.name }} {
-{%- for prop in class.node.properties %}
-{%- if prop.description %}
-    /// {{ prop.description | replace("\r\n", " ") | replace("\n", " ") | trim }}
-{%- endif %}
-    pub {{ prop.name | snakeCase }}: {{ rust.rustType(prop, typeMapper, polymorphicTypeNames) | trim }},
-{%- endfor %}
-}
-
-impl {{ class.node.typeName.name }} {
-    /// Create a new {{ class.node.typeName.name }} with default values.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Load {{ class.node.typeName.name }} from a JSON string.
-    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
-        let value: serde_json::Value = serde_json::from_str(json)?;
-        Ok(Self::load_from_value(&value, ctx))
-    }
-
-    /// Load {{ class.node.typeName.name }} from a YAML string.
-    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
-        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
-        Ok(Self::load_from_value(&value, ctx))
-    }
-
-    /// Load {{ class.node.typeName.name }} from a `serde_json::Value`.
-    ///
-    /// Calls `ctx.process_input` before field extraction.
-    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
-        let value = ctx.process_input(value.clone());
-        {%- if class.alternates.length > 0 %}
-        {%- for alt in class.alternates %}
-        {%- if alt.scalar == "String" %}
-        if let Some(s) = value.as_str() {
-            let value = s.to_string();
-            let expansion = serde_json::json!({{ alt.alternate }});
-            return Self::load_from_value(&expansion, ctx);
-        }
-        {%- elif alt.scalar == "bool" %}
-        if let Some(value) = value.as_bool() {
-            let expansion = serde_json::json!({{ alt.alternate }});
-            return Self::load_from_value(&expansion, ctx);
-        }
-        {%- elif alt.scalar in ["i64", "i32"] %}
-        if let Some(value) = value.as_i64() {
-            let expansion = serde_json::json!({{ alt.alternate }});
-            return Self::load_from_value(&expansion, ctx);
-        }
-        {%- elif alt.scalar in ["f64", "f32"] %}
-        if let Some(value) = value.as_f64() {
-            let expansion = serde_json::json!({{ alt.alternate }});
-            return Self::load_from_value(&expansion, ctx);
-        }
-        {%- endif %}
-        {%- endfor %}
-        {%- endif %}
-        Self {
-{%- for prop in class.node.properties %}
-            {{ prop.name | snakeCase }}: {{ rust.fieldInitializer(prop, "value", typeMapper, polymorphicTypeNames) | trim }},
-{%- endfor %}
-        }
-    }
-
-    /// Serialize {{ class.node.typeName.name }} to a `serde_json::Value`.
-    ///
-    /// Calls `ctx.process_dict` after serialization.
-    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
-        let mut result = serde_json::Map::new();
-{%- for prop in class.node.properties %}
-        {{ rust.saveProperty(prop, polymorphicTypeNames) | trim }}
-{%- endfor %}
-        ctx.process_dict(serde_json::Value::Object(result))
-    }
-
-    /// Serialize {{ class.node.typeName.name }} to a JSON string.
-    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
-        serde_json::to_string_pretty(&self.to_value(ctx))
-    }
-
-    /// Serialize {{ class.node.typeName.name }} to a YAML string.
-    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
-        serde_yaml::to_string(&self.to_value(ctx))
-    }
-
-{%- for prop in class.node.properties %}
-{%- if (prop.isCollection and not prop.isScalar and not prop.isDict) or prop.isDict %}
-    {{ rust.typedAccessor(prop) | trim }}
-
-{%- endif %}
-{%- endfor %}
-}
-{%- endif %}
-
-{% endfor %}
diff --git a/schema/emitter/src/templates/rust/lib.rs.njk b/schema/emitter/src/templates/rust/lib.rs.njk
deleted file mode 100644
index 73d8d165..00000000
--- a/schema/emitter/src/templates/rust/lib.rs.njk
+++ /dev/null
@@ -1,13 +0,0 @@
-{#
-  Rust mod.rs Template
-  ====================
-  Renders the mod.rs module declarations.
-
-  Expected context (RustLibContext):
-    - modules: string[]
-#}
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-{% for module in modules %}
-pub mod {{ module }};
-pub use {{ module }}::*;
-{% endfor %}
diff --git a/schema/emitter/src/templates/rust/test.rs.njk b/schema/emitter/src/templates/rust/test.rs.njk
deleted file mode 100644
index 991682f2..00000000
--- a/schema/emitter/src/templates/rust/test.rs.njk
+++ /dev/null
@@ -1,119 +0,0 @@
-{#
-  Rust Test Template
-  ==================
-  Renders integration test file for a TypeSpec model type.
-
-  Expected context (BaseTestContext):
-    - node: TypeNode
-    - isAbstract: boolean
-    - examples: Array<{ json: string[], yaml: string[], validations: Array<{ key, value, delimiter, isOptional }> }>
-    - alternates: Array<{ title, scalarType, value, validations: Array<{ key, value, delimiter, isOptional }> }>
-#}
-// Code generated by AgentSchema emitter; DO NOT EDIT.
-
-use {{ importPath }}::{{ node.typeName.name }};
-use {{ importPath }}::context::{LoadContext, SaveContext};
-
-{% for sample in examples %}
-#[test]
-fn test_{{ node.typeName.name | snakeCase }}_load_json{% if not loop.first %}_{{ loop.index - 1 }}{% endif %}() {
-    let json = r####"
-{%- for line in sample.json %}
-{{ line }}
-{%- endfor %}
-"####;
-    let ctx = LoadContext::default();
-    let result = {{ node.typeName.name }}::from_json(json, &ctx);
-    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());
-    {%- if not isAbstract %}
-    let instance = result.unwrap();
-    {%- if sample.validations.length > 0 %}
-    {%- for validation in sample.validations %}
-    {%- if validation.isOptional %}
-    assert!(instance.{{ validation.key }}.is_some(), "Expected {{ validation.key }} to be Some");
-    assert_eq!(instance.{{ validation.key }}.as_ref().unwrap(), &{{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }});
-    {%- elif isPolymorphicBase and validation.key == "kind" %}
-    assert_eq!(instance.kind_str(), {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }});
-    {%- else %}
-    assert_eq!(instance.{{ validation.key }}, {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }});
-    {%- endif %}
-    {%- endfor %}
-    {%- else %}
-    let _ = instance; // load succeeded, no scalar properties to validate
-    {%- endif %}
-    {%- endif %}
-}
-
-#[test]
-fn test_{{ node.typeName.name | snakeCase }}_load_yaml{% if not loop.first %}_{{ loop.index - 1 }}{% endif %}() {
-    let yaml = r####"
-{%- for line in sample.yaml %}
-{{ line }}
-{%- endfor %}
-"####;
-    let ctx = LoadContext::default();
-    let result = {{ node.typeName.name }}::from_yaml(yaml, &ctx);
-    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());
-    {%- if not isAbstract %}
-    let instance = result.unwrap();
-    {%- if sample.validations.length > 0 %}
-    {%- for validation in sample.validations %}
-    {%- if validation.isOptional %}
-    assert!(instance.{{ validation.key }}.is_some(), "Expected {{ validation.key }} to be Some");
-    {%- elif isPolymorphicBase and validation.key == "kind" %}
-    assert_eq!(instance.kind_str(), {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }});
-    {%- else %}
-    assert_eq!(instance.{{ validation.key }}, {{ validation.delimiter }}{{ validation.value }}{{ validation.delimiter }});
-    {%- endif %}
-    {%- endfor %}
-    {%- else %}
-    let _ = instance; // load succeeded, no scalar properties to validate
-    {%- endif %}
-    {%- endif %}
-}
-
-#[test]
-fn test_{{ node.typeName.name | snakeCase }}_roundtrip{% if not loop.first %}_{{ loop.index - 1 }}{% endif %}() {
-    let json = r####"
-{%- for line in sample.json %}
-{{ line }}
-{%- endfor %}
-"####;
-    let load_ctx = LoadContext::default();
-    let result = {{ node.typeName.name }}::from_json(json, &load_ctx);
-    assert!(result.is_ok(), "Failed to load: {:?}", result.err());
-    {%- if not isAbstract %}
-    let instance = result.unwrap();
-    let save_ctx = SaveContext::default();
-    let json_output = instance.to_json(&save_ctx);
-    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());
-    {%- endif %}
-}
-
-{% endfor %}
-{% for alt in alternates %}
-#[test]
-fn test_{{ node.typeName.name | snakeCase }}_from_{{ alt.title | lower }}{% if not loop.first %}_{{ loop.index }}{% endif %}() {
-    let value = serde_json::json!({{ alt.value }});
-    let ctx = LoadContext::default();
-    let instance = {{ node.typeName.name }}::load_from_value(&value, &ctx);
-    {%- if not isAbstract %}
-    {%- if alt.validations.length > 0 %}
-    {%- for item in alt.validations %}
-    {%- if item.isOptional %}
-    assert!(instance.{{ item.key }}.is_some());
-    {%- elif isPolymorphicBase and item.key == "kind" %}
-    assert_eq!(instance.kind_str(), {{ item.delimiter }}{{ item.value }}{{ item.delimiter }});
-    {%- else %}
-    assert_eq!(instance.{{ item.key }}, {{ item.delimiter }}{{ item.value }}{{ item.delimiter }});
-    {%- endif %}
-    {%- endfor %}
-    {%- else %}
-    let _ = instance; // load succeeded, no scalar properties to validate
-    {%- endif %}
-    {%- else %}
-    let _ = instance; // abstract type, load succeeded
-    {%- endif %}
-}
-
-{% endfor %}
diff --git a/schema/emitter/src/templates/typescript/_macros.njk b/schema/emitter/src/templates/typescript/_macros.njk
deleted file mode 100644
index 075ece35..00000000
--- a/schema/emitter/src/templates/typescript/_macros.njk
+++ /dev/null
@@ -1,165 +0,0 @@
-{#
-  TypeScript-Specific Macros for AgentSchema Emitter
-  ==================================================
-
-  These macros handle TypeScript-specific rendering logic.
-
-  Usage in TypeScript templates:
-    {% import "_macros.njk" as ts %}
-    {{ ts.tsType(prop, typeMapper) }}
-#}
-
-
-{# ============================================================================
-   Type Rendering
-   ============================================================================ #}
-
-{#
-  Convert a property to its TypeScript type annotation.
-
-  @param prop - PropertyNode with type information
-  @param typeMapper - Record<string, string> mapping TypeSpec types to TypeScript types
-#}
-{% macro tsType(prop, typeMapper) %}
-{%- set baseType = typeMapper[prop.typeName.name] if prop.isScalar else (typeMapper[prop.typeName.name] or prop.typeName.name) -%}
-{%- if not baseType %}{% set baseType = "unknown" %}{% endif -%}
-{%- if prop.isDict and prop.isOptional -%}
-Record<string, unknown> | undefined
-{%- elif prop.isDict -%}
-Record<string, unknown>
-{%- elif prop.isCollection -%}
-{{ baseType }}[]
-{%- elif prop.isOptional -%}
-{{ baseType }} | undefined
-{%- else -%}
-{{ baseType }}
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Default Value Rendering
-   ============================================================================ #}
-
-{#
-  Render the default value assignment for a class property.
-
-  @param prop - PropertyNode with type and default value information
-  @param typeMapper - Record<string, string> for type lookups
-#}
-{% macro defaultValue(prop, typeMapper) -%}
-{% if prop.isCollection and not prop.isDict %} = []
-{%- elif prop.isDict %} = {}
-{%- elif prop.isOptional %}
-{%- elif prop.isScalar -%}
-{%- if prop.typeName.name == "boolean" %} = {{ "true" if prop.defaultValue else "false" }}
-{%- elif prop.typeName.name == "string" %} = "{{ prop.defaultValue if prop.defaultValue else "" }}"
-{%- elif prop.typeName.name == "number" or prop.typeName.name == "integer" or prop.typeName.name == "int32" or prop.typeName.name == "int64" or prop.typeName.name == "float32" or prop.typeName.name == "float64" %} = {{ prop.defaultValue if prop.defaultValue else "0" }}
-{%- else %} = {{ prop.defaultValue if prop.defaultValue else "undefined" }}
-{%- endif -%}
-{%- endif -%}
-{% endmacro %}
-
-
-{#
-  Render the default initialization value for the constructor.
-
-  @param prop - PropertyNode with type and default value information
-  @param typeMapper - Record<string, string> for type lookups
-#}
-{% macro defaultInitValue(prop, typeMapper) -%}
-{%- if prop.isCollection -%}[]
-{%- elif prop.isDict -%}{}
-{%- elif prop.isScalar -%}
-{%- if prop.typeName.name == "boolean" -%}{{ "true" if prop.defaultValue else "false" }}
-{%- elif prop.typeName.name == "string" -%}"{{ prop.defaultValue if prop.defaultValue else "" }}"
-{%- elif prop.typeName.name == "number" or prop.typeName.name == "integer" or prop.typeName.name == "int32" or prop.typeName.name == "int64" or prop.typeName.name == "float32" or prop.typeName.name == "float64" -%}{{ prop.defaultValue if prop.defaultValue else "0" }}
-{%- else -%}undefined
-{%- endif -%}
-{%- else -%}undefined!
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Property Load Rendering
-   ============================================================================ #}
-
-{#
-  Render the property loading code.
-
-  @param prop - PropertyNode
-  @param instanceVar - Name of the instance variable
-  @param dataVar - Name of the data variable
-  @param classCtx - Class context
-#}
-{% macro loadProperty(prop, instanceVar, dataVar, classCtx) -%}
-{%- set propName = prop.name -%}
-{%- if prop.isCollection and not prop.isDict -%}
-{%- if prop.isScalar -%}
-{{ instanceVar }}.{{ propName }} = Array.isArray({{ dataVar }}["{{ propName }}"]) ? ({{ dataVar }}["{{ propName }}"] as unknown[]).map(v => String(v)) : [];
-{%- else -%}
-{{ instanceVar }}.{{ propName }} = {{ classCtx.node.typeName.name }}.load{{ pascalCase(prop.name) }}({{ dataVar }}["{{ propName }}"], context);
-{%- endif -%}
-{%- elif prop.isDict -%}
-{{ instanceVar }}.{{ propName }} = {{ dataVar }}["{{ propName }}"] as Record<string, unknown>;
-{%- elif not prop.isScalar -%}
-{{ instanceVar }}.{{ propName }} = {{ prop.typeName.name }}.load({{ dataVar }}["{{ propName }}"] as Record<string, unknown>, context);
-{%- elif prop.typeName.name == "string" -%}
-{{ instanceVar }}.{{ propName }} = String({{ dataVar }}["{{ propName }}"]);
-{%- elif prop.typeName.name == "number" or prop.typeName.name == "integer" or prop.typeName.name == "int32" or prop.typeName.name == "int64" or prop.typeName.name == "float32" or prop.typeName.name == "float64" -%}
-{{ instanceVar }}.{{ propName }} = Number({{ dataVar }}["{{ propName }}"]);
-{%- elif prop.typeName.name == "boolean" -%}
-{{ instanceVar }}.{{ propName }} = Boolean({{ dataVar }}["{{ propName }}"]);
-{%- else -%}
-{{ instanceVar }}.{{ propName }} = {{ dataVar }}["{{ propName }}"] as {{ prop.typeName.name }};
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   Property Save Rendering
-   ============================================================================ #}
-
-{#
-  Render the property saving code.
-
-  @param prop - PropertyNode
-  @param objVar - Name of the object variable
-  @param resultVar - Name of the result variable
-  @param classCtx - Class context
-#}
-{% macro saveProperty(prop, objVar, resultVar, classCtx) -%}
-{%- set propName = prop.name -%}
-{%- if prop.isCollection and not prop.isScalar and not prop.isDict -%}
-{{ resultVar }}["{{ propName }}"] = {{ classCtx.node.typeName.name }}.save{{ pascalCase(prop.name) }}({{ objVar }}.{{ propName }}, context);
-{%- elif not prop.isScalar and not prop.isDict -%}
-{{ resultVar }}["{{ propName }}"] = {{ objVar }}.{{ propName }}?.save(context);
-{%- else -%}
-{{ resultVar }}["{{ propName }}"] = {{ objVar }}.{{ propName }};
-{%- endif -%}
-{% endmacro %}
-
-
-{# ============================================================================
-   String Utilities
-   ============================================================================ #}
-
-{#
-  Convert a string to PascalCase.
-
-  @param str - The string to convert
-#}
-{% macro pascalCase(str) -%}
-{{ str.charAt(0).toUpperCase() + str.slice(1) }}
-{%- endmacro %}
-
-
-{#
-  Convert a string to kebab-case.
-
-  @param str - The string to convert
-#}
-{% macro kebabCase(str) -%}
-{{ str | lower | replace("_", "-") }}
-{%- endmacro %}
diff --git a/schema/emitter/src/templates/typescript/eslint.config.js.njk b/schema/emitter/src/templates/typescript/eslint.config.js.njk
deleted file mode 100644
index 66f8f499..00000000
--- a/schema/emitter/src/templates/typescript/eslint.config.js.njk
+++ /dev/null
@@ -1,41 +0,0 @@
-// ESLint configuration for auto-generated AgentSchema TypeScript code
-// This file is auto-generated by the AgentSchema emitter
-import js from "@eslint/js";
-import tseslint from "typescript-eslint";
-
-export default tseslint.config(
-  js.configs.recommended,
-  ...tseslint.configs.recommended,
-  {
-    files: ["src/**/*.ts"],
-    rules: {
-      // Allow unused vars prefixed with underscore
-      "@typescript-eslint/no-unused-vars": [
-        "error",
-        { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
-      ],
-      // Allow explicit any in generated code
-      "@typescript-eslint/no-explicit-any": "off",
-      // Allow non-null assertions in generated code
-      "@typescript-eslint/no-non-null-assertion": "off",
-      // Allow require() for dynamic YAML imports in generated code
-      "@typescript-eslint/no-require-imports": "off",
-      // Allow empty blocks in generated shorthand parsing patterns
-      "no-empty": "off",
-    },
-  },
-  {
-    files: ["tests/**/*.ts"],
-    rules: {
-      // Allow explicit any in test code
-      "@typescript-eslint/no-explicit-any": "off",
-      // Allow unused vars in generated tests
-      "@typescript-eslint/no-unused-vars": "off",
-      // Allow require() for dynamic YAML imports
-      "@typescript-eslint/no-require-imports": "off",
-    },
-  },
-  {
-    ignores: ["dist/**", "node_modules/**", "*.config.*"],
-  }
-);
diff --git a/schema/emitter/src/templates/typescript/file.ts.njk b/schema/emitter/src/templates/typescript/file.ts.njk
deleted file mode 100644
index b3d6072c..00000000
--- a/schema/emitter/src/templates/typescript/file.ts.njk
+++ /dev/null
@@ -1,376 +0,0 @@
-{#
-  TypeScript File Template
-  ========================
-  Renders a complete TypeScript file containing one or more classes.
-
-  Expected context (TypeScriptFileContext):
-    - containsAbstract: boolean
-    - imports: string[]
-    - classes: TypeScriptClassContext[]
-    - typeMapper: Record<string, string>
-    - namespace: string
-    - toKebabCase: function
-#}
-{%- import "_macros.njk" as ts -%}
-// Copyright (c) Microsoft. All rights reserved.
-// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
-
-import { LoadContext, SaveContext } from "./context";
-{%- for import in imports %}
-import { {{ import }} } from "./{{ toKebabCase(import) }}";
-{%- endfor %}
-
-{% for classCtx in classes %}
-{%- set node = classCtx.node -%}
-{%- set typeMapper = classCtx.typeMapper -%}
-{%- set alternates = classCtx.alternates -%}
-{%- set polymorphicTypes = classCtx.polymorphicTypes -%}
-{%- set collectionTypes = classCtx.collectionTypes %}
-
-/**
- * {% for line in node.description.split('\n') %}{{ line }}
- * {% endfor %}
- */
-export {% if node.isAbstract %}abstract {% endif %}class {{ node.typeName.name }}{% if node.base %} extends {{ node.base.name }}{% endif %} {
-  /**
-   * The shorthand property name for this type, if any.
-   */
-  static readonly shorthandProperty: string | undefined = {% if classCtx.shorthandProperty %}"{{ classCtx.shorthandProperty }}"{% else %}undefined{% endif %};
-
-  {% for prop in node.properties %}
-  /**
-   * {{ prop.description }}
-   */
-  {{ prop.name }}{% if prop.isOptional %}?{% endif %}: {{ ts.tsType(prop, typeMapper) }}{{ ts.defaultValue(prop, typeMapper) }};
-  {% endfor %}
-
-  /**
-   * Initializes a new instance of {{ node.typeName.name }}.
-   */
-  constructor(init?: Partial<{{ node.typeName.name }}>) {
-    {% if node.base %}super(init);{% endif %}
-    {% for prop in node.properties %}
-    {% if not prop.isOptional %}
-    this.{{ prop.name }} = init?.{{ prop.name }} ?? {{ ts.defaultInitValue(prop, typeMapper) }};
-    {% else %}
-    if (init?.{{ prop.name }} !== undefined) {
-      this.{{ prop.name }} = init.{{ prop.name }};
-    }
-    {% endif %}
-    {%- endfor %}
-  }
-
-  //#region Load Methods
-
-  /**
-   * Load a {{ node.typeName.name }} instance from a dictionary.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded {{ node.typeName.name }} instance.
-   */
-  static load(data: Record<string, unknown>, context?: LoadContext): {{ node.typeName.name }} {
-    if (context) {
-      data = context.processInput(data);
-    }
-    {% if alternates.length > 0 %}
-    // Handle alternate representations
-    if (typeof data === "string") {
-      {%- for alt in alternates %}{% if alt.scalar == "string" %}
-      data = {{ alt.alternate }};
-      {%- endif %}{% endfor %}
-    } else if (typeof data === "number") {
-      {%- for alt in alternates %}{% if alt.scalar == "number" %}
-      // Check if it's an integer or float
-      if (Number.isInteger(data)) {
-        {%- for intAlt in alternates %}{% if intAlt.scalar == "number" and "integer" in intAlt.alternate %}
-        data = {{ intAlt.alternate }};
-        {%- endif %}{% endfor %}
-      } else {
-        {%- for floatAlt in alternates %}{% if floatAlt.scalar == "number" and "float" in floatAlt.alternate %}
-        data = {{ floatAlt.alternate }};
-        {%- endif %}{% endfor %}
-      }
-      {%- endif %}{% endfor %}
-    } else if (typeof data === "boolean") {
-      {%- for alt in alternates %}{% if alt.scalar == "boolean" %}
-      data = {{ alt.alternate }};
-      {%- endif %}{% endfor %}
-    }
-    {% endif %}
-    {% if polymorphicTypes %}
-    // Load polymorphic {{ node.typeName.name }} instance
-    const instance = {{ node.typeName.name }}.load{{ ts.pascalCase(node.discriminator) }}(data, context);
-    {% else %}
-    // Create new instance
-    const instance = new {{ node.typeName.name }}();
-    {% endif %}
-    {% for prop in node.properties %}
-    if (data["{{ prop.name }}"] !== undefined && data["{{ prop.name }}"] !== null) {
-      {{ ts.loadProperty(prop, "instance", "data", classCtx) }}
-    }
-    {% endfor %}
-    if (context) {
-      return context.processOutput(instance) as {{ node.typeName.name }};
-    }
-    return instance;
-  }
-  {% for collection in collectionTypes %}
-
-  /**
-   * Load a collection of {{ collection.prop.typeName.name }} from a dictionary or array.
-   * @param data - The data to load from.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded array of {{ collection.prop.typeName.name }}.
-   */
-  static load{{ ts.pascalCase(collection.prop.name) }}(data: unknown, context?: LoadContext): {{ collection.prop.typeName.name }}[] {
-    const result: {{ collection.prop.typeName.name }}[] = [];
-
-    if (data && typeof data === "object" && !Array.isArray(data)) {
-      // Convert named dictionary to array
-      for (const [key, value] of Object.entries(data as Record<string, unknown>)) {
-        if (Array.isArray(value)) {
-          throw new Error(
-            `Invalid '{{ collection.prop.name }}' format: key '${key}' has an array value. ` +
-            `'{{ collection.prop.name }}' must be a flat list of objects or a name-keyed dict — ` +
-            `not a nested { ${key}: [...] } structure.`,
-          );
-        }
-        if (value && typeof value === "object") {
-          // Value is an object, add name to it
-          (value as Record<string, unknown>)["name"] = key;
-          result.push({{ collection.prop.typeName.name }}.load(value as Record<string, unknown>, context));
-        } else {
-          // Value is a scalar — let {{ collection.prop.typeName.name }}.load() infer kind from value
-          const prop = {{ collection.prop.typeName.name }}.load(value as Record<string, unknown>, context);
-          prop.name = key;
-          result.push(prop);
-        }
-      }
-    } else if (Array.isArray(data)) {
-      for (const item of data) {
-        if (item && typeof item === "object") {
-          result.push({{ collection.prop.typeName.name }}.load(item as Record<string, unknown>, context));
-        }
-      }
-    }
-
-    return result;
-  }
-  {% endfor %}
-  {% if polymorphicTypes %}
-
-  /**
-   * Load polymorphic {{ node.typeName.name }} based on discriminator.
-   * @param data - The dictionary containing the data.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded {{ node.typeName.name }} instance.
-   */
-  private static load{{ ts.pascalCase(node.discriminator) }}(data: Record<string, unknown>, context?: LoadContext): {{ node.typeName.name }} {
-    const discriminatorValue = data["{{ node.discriminator }}"];
-    if (discriminatorValue !== undefined && discriminatorValue !== null) {
-      const discriminator = String(discriminatorValue).toLowerCase();
-      switch (discriminator) {
-        {%- for type in polymorphicTypes.types %}
-        case "{{ type.value }}":
-          return {{ type.instance.typeName.name }}.load(data, context);
-        {%- endfor %}
-        default:
-          {%- if polymorphicTypes.default %}
-          {%- if polymorphicTypes.default.instance.typeName.name == node.typeName.name %}
-          return new {{ node.typeName.name }}();
-          {%- else %}
-          return {{ polymorphicTypes.default.instance.typeName.name }}.load(data, context);
-          {%- endif %}
-          {%- else %}
-          throw new Error(`Unknown {{ node.typeName.name }} discriminator value: ${discriminator}`);
-          {%- endif %}
-      }
-    }
-    {% if node.isAbstract %}
-    throw new Error("Missing {{ node.typeName.name }} discriminator property: '{{ node.discriminator }}'");
-    {% else %}
-    return new {{ node.typeName.name }}();
-    {% endif %}
-  }
-  {% endif %}
-
-  //#endregion
-
-  //#region Save Methods
-
-  /**
-   * Save the {{ node.typeName.name }} instance to a dictionary.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The dictionary representation of this instance.
-   */
-  save(context?: SaveContext): Record<string, unknown> {
-    const obj = context ? context.processObject(this) as {{ node.typeName.name }} : this;
-
-    {% if node.base %}
-    // Start with parent class properties
-    const result = super.save(context);
-    {% else %}
-    const result: Record<string, unknown> = {};
-    {% endif %}
-    {% for prop in node.properties %}
-    if (obj.{{ prop.name }} !== undefined && obj.{{ prop.name }} !== null) {
-      {{ ts.saveProperty(prop, "obj", "result", classCtx) }}
-    }
-    {% endfor %}
-    {% if not node.base %}
-    if (context) {
-      return context.processDict(result);
-    }
-    {% endif %}
-    return result;
-  }
-  {% for collection in collectionTypes %}
-
-  /**
-   * Save a collection of {{ collection.prop.typeName.name }} to object or array format.
-   * @param items - The items to save.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The saved collection in object or array format.
-   */
-  static save{{ ts.pascalCase(collection.prop.name) }}(items: {{ collection.prop.typeName.name }}[], context?: SaveContext): Record<string, unknown> | Record<string, unknown>[] {
-    context = context ?? new SaveContext();
-{% if collection.hasNameProperty %}
-    if (context.collectionFormat === "array") {
-      return items.map((item) => item.save(context));
-    }
-
-    // Object format: use name as key
-    const result: Record<string, unknown> = {};
-    for (const item of items) {
-      const itemData = item.save(context);
-      const name = itemData["name"] as string | undefined;
-      if (name) {
-        delete itemData["name"];
-
-        // Check if we can use shorthand
-        if (context.useShorthand && {{ collection.prop.typeName.name }}.shorthandProperty) {
-          const shorthandProp = {{ collection.prop.typeName.name }}.shorthandProperty;
-          const keys = Object.keys(itemData);
-          if (keys.length === 1 && keys[0] === shorthandProp) {
-            result[name] = itemData[shorthandProp];
-            continue;
-          }
-        }
-        result[name] = itemData;
-      } else {
-        throw new Error("Cannot save item in object format: missing 'name' property");
-      }
-    }
-    return result;
-{% else %}
-    // This type doesn't have a 'name' property, so always use array format
-    return items.map((item) => item.save(context));
-{% endif %}
-  }
-  {% endfor %}
-
-  /**
-   * Convert the {{ node.typeName.name }} instance to a YAML string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The YAML string representation of this instance.
-   */
-  toYaml(context?: SaveContext): string {
-    context = context ?? new SaveContext();
-    return context.toYaml(this.save(context));
-  }
-
-  /**
-   * Convert the {{ node.typeName.name }} instance to a JSON string.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @param indent - Number of spaces for indentation. Defaults to 2.
-   * @returns The JSON string representation of this instance.
-   */
-  toJson(context?: SaveContext, indent: number = 2): string {
-    context = context ?? new SaveContext();
-    return context.toJson(this.save(context), indent);
-  }
-
-  /**
-   * Load a {{ node.typeName.name }} instance from a JSON string.
-   * @param json - The JSON string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded {{ node.typeName.name }} instance.
-   */
-  static fromJson(json: string, context?: LoadContext): {{ node.typeName.name }} {
-    const data = JSON.parse(json);
-    {% if alternates.length > 0 %}
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        {%- for alt in alternates %}{% if alt.scalar == "string" %}
-        return {{ node.typeName.name }}.load({{ alt.alternate }}, context);
-        {%- endif %}{% endfor %}
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-          {%- for intAlt in alternates %}{% if intAlt.scalar == "number" and "integer" in intAlt.alternate %}
-          return {{ node.typeName.name }}.load({{ intAlt.alternate }}, context);
-          {%- endif %}{% endfor %}
-        } else {
-          {%- for floatAlt in alternates %}{% if floatAlt.scalar == "number" and "float" in floatAlt.alternate %}
-          return {{ node.typeName.name }}.load({{ floatAlt.alternate }}, context);
-          {%- endif %}{% endfor %}
-        }
-      } else if (typeof data === "boolean") {
-        {%- for alt in alternates %}{% if alt.scalar == "boolean" %}
-        return {{ node.typeName.name }}.load({{ alt.alternate }}, context);
-        {%- endif %}{% endfor %}
-      }
-      // Fallback - shouldn't reach here
-      {%- for alt in alternates %}{% if loop.first %}
-      return {{ node.typeName.name }}.load({{ alt.alternate }}, context);
-      {%- endif %}{% endfor %}
-    }
-    {% endif %}
-    return {{ node.typeName.name }}.load(data as Record<string, unknown>, context);
-  }
-
-  /**
-   * Load a {{ node.typeName.name }} instance from a YAML string.
-   * @param yaml - The YAML string to parse.
-   * @param context - Optional context with pre/post processing callbacks.
-   * @returns The loaded {{ node.typeName.name }} instance.
-   */
-  static fromYaml(yaml: string, context?: LoadContext): {{ node.typeName.name }} {
-    const { parse } = require("yaml");
-    const data = parse(yaml);
-    {% if alternates.length > 0 %}
-    // Handle alternate representations
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      if (typeof data === "string") {
-        {%- for alt in alternates %}{% if alt.scalar == "string" %}
-        return {{ node.typeName.name }}.load({{ alt.alternate }}, context);
-        {%- endif %}{% endfor %}
-      } else if (typeof data === "number") {
-        // Check if it's an integer or float
-        if (Number.isInteger(data)) {
-          {%- for intAlt in alternates %}{% if intAlt.scalar == "number" and "integer" in intAlt.alternate %}
-          return {{ node.typeName.name }}.load({{ intAlt.alternate }}, context);
-          {%- endif %}{% endfor %}
-        } else {
-          {%- for floatAlt in alternates %}{% if floatAlt.scalar == "number" and "float" in floatAlt.alternate %}
-          return {{ node.typeName.name }}.load({{ floatAlt.alternate }}, context);
-          {%- endif %}{% endfor %}
-        }
-      } else if (typeof data === "boolean") {
-        {%- for alt in alternates %}{% if alt.scalar == "boolean" %}
-        return {{ node.typeName.name }}.load({{ alt.alternate }}, context);
-        {%- endif %}{% endfor %}
-      }
-      // Fallback - shouldn't reach here
-      {%- for alt in alternates %}{% if loop.first %}
-      return {{ node.typeName.name }}.load({{ alt.alternate }}, context);
-      {%- endif %}{% endfor %}
-    }
-    {% endif %}
-    return {{ node.typeName.name }}.load(data as Record<string, unknown>, context);
-  }
-
-  //#endregion
-}
-{% endfor %}
diff --git a/schema/emitter/src/templates/typescript/index.ts.njk b/schema/emitter/src/templates/typescript/index.ts.njk
deleted file mode 100644
index 12533637..00000000
--- a/schema/emitter/src/templates/typescript/index.ts.njk
+++ /dev/null
@@ -1,26 +0,0 @@
-{#
-  TypeScript index.ts Template
-  ============================
-  Renders the index.ts file that exports all types.
-
-  Expected context (TypeScriptIndexContext):
-    - baseTypes: TypeNode[] - Types without a parent for imports
-    - types: TypeNode[] - All types for export
-    - toKebabCase: function - Convert PascalCase to kebab-case
-#}
-// Copyright (c) Microsoft. All rights reserved.
-// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
-
-export { LoadContext, SaveContext } from "./context";
-{%- for type in baseTypes %}
-{% if type.childTypes.length > 0 %}
-export {
-  {{ type.typeName.name }},
-  {%- for child in type.childTypes %}
-  {{ child.typeName.name }},
-  {%- endfor %}
-} from "./{{ toKebabCase(type.typeName.name) }}";
-{% else %}
-export { {{ type.typeName.name }} } from "./{{ toKebabCase(type.typeName.name) }}";
-{% endif %}
-{%- endfor %}
diff --git a/schema/emitter/src/templates/typescript/test.ts.njk b/schema/emitter/src/templates/typescript/test.ts.njk
deleted file mode 100644
index 5f02264b..00000000
--- a/schema/emitter/src/templates/typescript/test.ts.njk
+++ /dev/null
@@ -1,116 +0,0 @@
-{#
-  TypeScript Test Template
-  ========================
-  Renders test files for TypeScript classes.
-
-  Expected context (BaseTestContext):
-    - node: TypeNode
-    - isAbstract: boolean
-    - examples: Array<{ json: string[], yaml: string[], validations: Array<{ key, value, delimiter, isOptional }> }>
-    - alternates: Array<{ title: string, scalarType: string, value: string, validations: Array<...> }>
-    - renderName: function
-    - namespace: string
-#}
-// Copyright (c) Microsoft. All rights reserved.
-// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
-
-import { {{ node.typeName.name }} } from "{{ importPath }}";
-
-describe("{{ node.typeName.name }}", () => {
-  describe("construction", () => {
-    it("should create a new instance with defaults", () => {
-      const instance = new {{ node.typeName.name }}();
-      expect(instance).toBeDefined();
-    });
-
-    it("should create a new instance with partial initialization", () => {
-      const instance = new {{ node.typeName.name }}({});
-      expect(instance).toBeDefined();
-    });
-  });
-  {% if examples.length > 0 %}
-
-  describe("JSON serialization", () => {
-    {% for example in examples %}
-    it("should load from JSON - example {{ loop.index }}", () => {
-      const json = `{{ example.json | join("\\n") | safe }}`;
-      const instance = {{ node.typeName.name }}.fromJson(json);
-      expect(instance).toBeDefined();
-      {% for val in example.validations %}
-      expect(instance.{{ val.key }}).toEqual({{ val.delimiter }}{{ val.value }}{{ val.delimiter }});
-      {% endfor %}
-    });
-
-    it("should round-trip JSON - example {{ loop.index }}", () => {
-      const json = `{{ example.json | join("\\n") | safe }}`;
-      const instance = {{ node.typeName.name }}.fromJson(json);
-      const output = instance.toJson();
-      const reloaded = {{ node.typeName.name }}.fromJson(output);
-      {% for val in example.validations %}
-      expect(reloaded.{{ val.key }}).toEqual(instance.{{ val.key }});
-      {% endfor %}
-    });
-    {% endfor %}
-  });
-
-  describe("YAML serialization", () => {
-    {% for example in examples %}
-    it("should load from YAML - example {{ loop.index }}", () => {
-      const yaml = `{{ example.yaml | join("\\n") | safe }}`;
-      const instance = {{ node.typeName.name }}.fromYaml(yaml);
-      expect(instance).toBeDefined();
-      {% for val in example.validations %}
-      expect(instance.{{ val.key }}).toEqual({{ val.delimiter }}{{ val.value }}{{ val.delimiter }});
-      {% endfor %}
-    });
-
-    it("should round-trip YAML - example {{ loop.index }}", () => {
-      const yaml = `{{ example.yaml | join("\\n") | safe }}`;
-      const instance = {{ node.typeName.name }}.fromYaml(yaml);
-      const output = instance.toYaml();
-      const reloaded = {{ node.typeName.name }}.fromYaml(output);
-      {% for val in example.validations %}
-      expect(reloaded.{{ val.key }}).toEqual(instance.{{ val.key }});
-      {% endfor %}
-    });
-    {% endfor %}
-  });
-  {% endif %}
-  {% if alternates.length > 0 %}
-
-  describe("alternate representations", () => {
-    {% for alt in alternates %}
-    it("should handle {{ alt.title }} alternate representation", () => {
-      const value = {{ alt.value }};
-      const json = JSON.stringify(value);
-      const instance = {{ node.typeName.name }}.fromJson(json);
-      expect(instance).toBeDefined();
-      {% for val in alt.validations %}
-      expect(instance.{{ renderName(val.key) | lower | replace(".", "") }}).toEqual({{ val.delimiter }}{{ val.value }}{{ val.delimiter }});
-      {% endfor %}
-    });
-    {% endfor %}
-  });
-  {% endif %}
-
-  {% if not (isAbstract and node.isAbstract) %}
-  describe("load and save", () => {
-    {% if not isAbstract %}
-    it("should load from dictionary", () => {
-      const data: Record<string, unknown> = {};
-      const instance = {{ node.typeName.name }}.load(data);
-      expect(instance).toBeDefined();
-    });
-    {% endif %}
-
-    {% if not node.isAbstract %}
-    it("should save to dictionary", () => {
-      const instance = new {{ node.typeName.name }}();
-      const data = instance.save();
-      expect(data).toBeDefined();
-      expect(typeof data).toBe("object");
-    });
-    {% endif %}
-  });
-  {% endif %}
-});
diff --git a/schema/emitter/src/testing/index.ts b/schema/emitter/src/testing/index.ts
index 183facf4..9ee55922 100644
--- a/schema/emitter/src/testing/index.ts
+++ b/schema/emitter/src/testing/index.ts
@@ -3,6 +3,6 @@ import { createTestLibrary, TypeSpecTestLibrary } from "@typespec/compiler/testi
 import { fileURLToPath } from "url";
 
 export const PromptyEmitTestLibrary: TypeSpecTestLibrary = createTestLibrary({
-  name: "agentschema-emit",
+  name: "prompty-emitter",
   packageRoot: resolvePath(fileURLToPath(import.meta.url), "../../../../"),
 });
diff --git a/schema/emitter/src/test-context.ts b/schema/emitter/src/testing/test-context.ts
similarity index 93%
rename from schema/emitter/src/test-context.ts
rename to schema/emitter/src/testing/test-context.ts
index 66adb2ab..1b1fc8bd 100644
--- a/schema/emitter/src/test-context.ts
+++ b/schema/emitter/src/testing/test-context.ts
@@ -5,8 +5,8 @@
  * This ensures consistency in how tests are generated from @sample decorators.
  */
 
-import { TypeNode, PropertyValidation, TestExample, AlternateTest, BaseTestContext } from "./ast.js";
-import { getCombinations, scalarValue } from "./utilities.js";
+import { TypeNode, PropertyValidation, TestExample, CoercionTest, BaseTestContext } from "../ir/ast.js";
+import { getCombinations, scalarValue, toSnakeCase } from "../ir/utilities.js";
 import * as YAML from "yaml";
 
 /**
@@ -48,7 +48,7 @@ export function buildBaseTestContext(
   options: TestContextOptions
 ): BaseTestContext {
   const examples = buildExamples(node, options);
-  const alternates = buildAlternates(node, options);
+  const coercions = buildCoercions(node, options);
   const isAbstract = node.isAbstract || (node.discriminator !== undefined && node.discriminator.length > 0);
 
   return {
@@ -56,7 +56,8 @@ export function buildBaseTestContext(
     isAbstract,
     package: packageName,
     examples,
-    alternates,
+    coercions,
+    factories: node.factories,
   };
 }
 
@@ -143,14 +144,14 @@ function buildValidations(
 }
 
 /**
- * Build alternate/shorthand test cases from node alternates.
+ * Build coercion (scalar-to-object) test cases from node coercions.
  */
-function buildAlternates(node: TypeNode, options: TestContextOptions): AlternateTest[] {
-  if (!node.alternates || node.alternates.length === 0) {
+function buildCoercions(node: TypeNode, options: TestContextOptions): CoercionTest[] {
+  if (!node.coercions || node.coercions.length === 0) {
     return [];
   }
 
-  return node.alternates.map(alt => {
+  return node.coercions.map(alt => {
     // Get example value - use provided example or default scalar value
     const example = alt.example
       ? (typeof alt.example === "string" ? '"' + alt.example + '"' : alt.example.toString())
@@ -199,7 +200,7 @@ export const csharpTestOptions: TestContextOptions = {
     return pascal.charAt(0).toUpperCase() + pascal.slice(1);
   },
   renderBoolean: (val: boolean) => val ? "True" : "False",
-  escapeString: (str: string) => str,
+  escapeString: (str: string) => str.replace(/\\/g, "\\\\").replace(/"/g, '\\"'),
   getDelimiter: (str: string) => str.includes('\n') ? '@"' : '"',
   scalarValues: {
     "boolean": "false",
@@ -227,9 +228,9 @@ export const csharpTestOptions: TestContextOptions = {
  * Python test context options.
  */
 export const pythonTestOptions: TestContextOptions = {
-  renderKey: (key: string) => key, // snake_case - already correct from TypeSpec
+  renderKey: (key: string) => toSnakeCase(key), // camelCase from TypeSpec → snake_case for Python
   renderBoolean: (val: boolean) => val ? "True" : "False",
-  escapeString: (str: string) => str,
+  escapeString: (str: string) => str.replace(/\\/g, "\\\\").replace(/"/g, '\\"'),
   getDelimiter: (str: string) => str.includes('\n') ? '"""' : '"',
   scalarValues: {
     "boolean": "False",
diff --git a/schema/emitter/src/typescript.ts b/schema/emitter/src/typescript.ts
deleted file mode 100644
index 7479f12a..00000000
--- a/schema/emitter/src/typescript.ts
+++ /dev/null
@@ -1,490 +0,0 @@
-import { EmitContext, emitFile, resolvePath } from "@typespec/compiler";
-import { EmitTarget, PromptyEmitterOptions } from "./lib.js";
-import { enumerateTypes, PropertyNode, TypeNode, BaseTestContext } from "./ast.js";
-import { GeneratorOptions, filterNodes } from "./emitter.js";
-import * as nunjucks from "nunjucks";
-import { buildBaseTestContext, typescriptTestOptions } from "./test-context.js";
-import { toKebabCase } from "./utilities.js";
-import path from "path";
-import { resolve, dirname } from "path";
-import { execSync } from "child_process";
-import { existsSync } from "fs";
-
-/**
- * TypeScript type mapper - converts TypeSpec types to TypeScript types.
- */
-const typescriptTypeMapper: Record<string, string> = {
-  "string": "string",
-  "number": "number",
-  "array": "[]",
-  "object": "object",
-  "boolean": "boolean",
-  "int64": "number",
-  "int32": "number",
-  "float64": "number",
-  "float32": "number",
-  "integer": "number",
-  "dictionary": "Record<string, unknown>",
-  "unknown": "unknown",
-};
-
-/**
- * TypeScript file context for rendering.
- */
-interface TypeScriptClassContext {
-  node: TypeNode;
-  typeMapper: Record<string, string>;
-  alternates: Array<{ scalar: string; alternate: string }>;
-  polymorphicTypes: any;
-  imports: string[];
-  collectionTypes: Array<{ prop: PropertyNode; type: string[] }>;
-  shorthandProperty: string | null;
-}
-
-interface TypeScriptFileContext {
-  containsAbstract: boolean;
-  imports: string[];
-  classes: TypeScriptClassContext[];
-  typeMapper: Record<string, string>;
-}
-
-interface TypeScriptIndexContext {
-  baseTypes: TypeNode[];
-  types: TypeNode[];
-}
-
-interface TypeScriptContextContext {
-  header: string;
-  package?: string;
-}
-
-/**
- * Generate TypeScript code from TypeSpec models.
- */
-export const generateTypeScript = async (
-  context: EmitContext<PromptyEmitterOptions>,
-  templateDir: string,
-  node: TypeNode,
-  emitTarget: EmitTarget,
-  options?: GeneratorOptions
-) => {
-  // Set up template environment
-  const templatePath = path.resolve(templateDir, "typescript");
-  const env = new nunjucks.Environment(new nunjucks.FileSystemLoader(templatePath), {
-    autoescape: false, // Disable HTML auto-escaping for code generation
-  });
-
-  // Add custom filters
-  env.addFilter("isFloat", function (value: any) {
-    return value.toString().includes(".");
-  });
-
-  // Load templates
-  const fileTemplate = env.getTemplate("file.ts.njk", true);
-  const contextTemplate = env.getTemplate("context.ts.njk", true);
-  const indexTemplate = env.getTemplate("index.ts.njk", true);
-  const testTemplate = env.getTemplate("test.ts.njk", true);
-  const eslintConfigTemplate = env.getTemplate("eslint.config.js.njk", true);
-
-  const nodes = filterNodes(Array.from(enumerateTypes(node)), options);
-
-  // Determine namespace: use override or default
-  const originalNamespace = node.typeName.namespace;
-  const tsNamespace = emitTarget.namespace ?? originalNamespace.replace(/\.Core$/, "");
-
-  // Emit context classes (LoadContext, SaveContext)
-  const contextCode = contextTemplate.render(buildContextContext(tsNamespace));
-  await emitTypeScriptFile(context, "context.ts", contextCode, emitTarget["output-dir"]);
-
-  // Emit each base type file (includes children in the same file)
-  for (const n of nodes) {
-    // Skip child types - they're rendered with their parent
-    if (n.base) {
-      continue;
-    }
-
-    const fileContext = buildFileContext(n);
-    const code = fileTemplate.render({
-      ...fileContext,
-      namespace: tsNamespace,
-      renderPropertyName,
-      renderName,
-      renderType,
-      renderSimpleType,
-      renderDefault,
-      renderLoadProperty: renderLoadProperty(nodes),
-      renderSaveProperty,
-      toKebabCase,
-    });
-    await emitTypeScriptFile(context, `${toKebabCase(n.typeName.name)}.ts`, code, emitTarget["output-dir"]);
-  }
-
-  // Emit test files for all types
-  if (emitTarget["test-dir"]) {
-    const importPath = emitTarget["import-path"] || "../src/index";
-    for (const n of nodes) {
-      const testContext = buildTestContext(n);
-      const testCode = testTemplate.render({
-        ...testContext,
-        importPath,
-        renderName,
-        namespace: tsNamespace,
-        toKebabCase,
-      });
-      await emitTypeScriptFile(context, `${toKebabCase(n.typeName.name)}.test.ts`, testCode, emitTarget["test-dir"]);
-    }
-  }
-
-  // Emit index.ts file
-  const indexContext = buildIndexContext(nodes);
-  const indexCode = indexTemplate.render({
-    ...indexContext,
-    toKebabCase,
-  });
-  await emitTypeScriptFile(context, "index.ts", indexCode, emitTarget["output-dir"]);
-
-  // Emit eslint.config.js to project root (parent of output-dir)
-  if (emitTarget["output-dir"]) {
-    const projectRoot = resolve(process.cwd(), emitTarget["output-dir"], "..");
-    const eslintConfigCode = eslintConfigTemplate.render({});
-    await emitTypeScriptFile(context, "eslint.config.js", eslintConfigCode, projectRoot);
-  }
-
-  // Format emitted files if format option is enabled (default: true)
-  if (emitTarget.format !== false) {
-    const outputDir = emitTarget["output-dir"]
-      ? resolve(process.cwd(), emitTarget["output-dir"])
-      : context.emitterOutputDir;
-    const testDir = emitTarget["test-dir"]
-      ? resolve(process.cwd(), emitTarget["test-dir"])
-      : undefined;
-
-    formatTypeScriptFiles(outputDir, testDir);
-  }
-};
-
-/**
- * Format TypeScript files using prettier.
- */
-function formatTypeScriptFiles(outputDir: string, testDir?: string): void {
-  const projectRoot = findTypeScriptProjectRoot(outputDir);
-  if (!projectRoot) {
-    console.warn(`Warning: Could not find package.json. Skipping formatting.`);
-    return;
-  }
-
-  const dirs = [outputDir, ...(testDir ? [testDir] : [])];
-
-  for (const dir of dirs) {
-    // Run prettier
-    try {
-      execSync(`npx prettier --write "${dir}/**/*.ts"`, {
-        cwd: projectRoot,
-        stdio: "pipe",
-        encoding: "utf-8",
-      });
-    } catch (error) {
-      console.warn(`Warning: prettier formatting failed for ${dir}. You may need to install prettier.`);
-    }
-
-    // Run eslint fix
-    try {
-      execSync(`npx eslint --fix "${dir}/**/*.ts"`, {
-        cwd: projectRoot,
-        stdio: "pipe",
-        encoding: "utf-8",
-      });
-    } catch (error) {
-      // ESLint errors are common, don't warn about them
-    }
-  }
-}
-
-/**
- * Find the TypeScript project root by looking for package.json.
- */
-function findTypeScriptProjectRoot(startDir: string): string | undefined {
-  let currentDir = resolve(startDir);
-  const root = resolve("/");
-
-  while (currentDir !== root && currentDir !== dirname(currentDir)) {
-    const packageJsonPath = resolve(currentDir, "package.json");
-    if (existsSync(packageJsonPath)) {
-      return currentDir;
-    }
-    currentDir = dirname(currentDir);
-  }
-
-  return undefined;
-}
-
-/**
- * Build context for rendering a single TypeScript class.
- */
-function buildClassContext(node: TypeNode): TypeScriptClassContext {
-  return {
-    node,
-    typeMapper: typescriptTypeMapper,
-    alternates: prepareAlternates(node),
-    polymorphicTypes: node.retrievePolymorphicTypes(),
-    imports: getUniqueImportTypes(node),
-    collectionTypes: getCollectionTypes(node),
-    shorthandProperty: getShorthandProperty(node),
-  };
-}
-
-/**
- * Build context for rendering a TypeScript file with a base type and its children.
- */
-function buildFileContext(node: TypeNode): TypeScriptFileContext {
-  const classes: TypeScriptClassContext[] = [
-    buildClassContext(node),
-    ...node.childTypes.map((ct) => buildClassContext(ct)),
-  ];
-
-  return {
-    containsAbstract: node.isAbstract || node.childTypes.some((c) => c.isAbstract),
-    imports: getUniqueImportTypes(node),
-    classes,
-    typeMapper: typescriptTypeMapper,
-  };
-}
-
-/**
- * Build context for rendering the index.ts file.
- */
-function buildIndexContext(nodes: TypeNode[]): TypeScriptIndexContext {
-  return {
-    baseTypes: nodes.filter((n) => !n.base),
-    types: nodes,
-  };
-}
-
-/**
- * Build context for rendering a test file.
- */
-function buildTestContext(node: TypeNode): BaseTestContext {
-  return buildBaseTestContext(node, undefined, typescriptTestOptions);
-}
-
-/**
- * Build context for rendering the context.ts file.
- */
-function buildContextContext(namespace?: string): TypeScriptContextContext {
-  return {
-    header: "Prompty Context",
-    package: namespace,
-  };
-}
-
-/**
- * Prepare alternate representations for template rendering.
- */
-function prepareAlternates(node: TypeNode): Array<{ scalar: string; alternate: string }> {
-  if (!node.alternates || node.alternates.length === 0) {
-    return [];
-  }
-
-  return node.alternates.map((alt) => ({
-    scalar: typescriptTypeMapper[alt.scalar] || alt.scalar,
-    alternate: JSON.stringify(alt.expansion, null, "")
-      .replaceAll("\n", "")
-      .replaceAll('"{value}"', "data"),
-  }));
-}
-
-/**
- * Get shorthand property name from alternates.
- */
-function getShorthandProperty(node: TypeNode): string | null {
-  if (!node.alternates || node.alternates.length === 0) {
-    return null;
-  }
-
-  for (const alt of node.alternates) {
-    for (const [key, value] of Object.entries(alt.expansion)) {
-      if (value === "{value}") {
-        return key;
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Get collection properties with their nested type info.
- */
-function getCollectionTypes(node: TypeNode): Array<{ prop: PropertyNode; type: string[]; hasNameProperty: boolean }> {
-  return node.properties
-    .filter((p) => p.isCollection && !p.isScalar && !p.isDict)
-    .map((p) => ({
-      prop: p,
-      type: p.type?.properties.filter((t) => t.name !== "name").map((t) => t.name) || [],
-      hasNameProperty: p.type?.properties.some((t) => t.name === "name") || false,
-    }));
-}
-
-/**
- * Get unique import types needed from other modules.
- */
-function getUniqueImportTypes(node: TypeNode): string[] {
-  const imports = [
-    node.properties.filter((p) => !p.isScalar && !p.isDict).map((p) => p.typeName.name),
-    ...node.childTypes.flatMap((c) =>
-      c.properties.filter((p) => !p.isScalar && !p.isDict).map((p) => p.typeName.name)
-    ),
-  ]
-    .flat()
-    .filter((n) => n !== node.typeName.name && node.base?.name !== n);
-
-  return Array.from(new Set(imports)).sort();
-}
-
-/**
- * Write generated TypeScript content to file.
- */
-async function emitTypeScriptFile(
-  context: EmitContext<PromptyEmitterOptions>,
-  filename: string,
-  content: string,
-  outputDir?: string
-): Promise<void> {
-  outputDir = outputDir || `${context.emitterOutputDir}/typescript`;
-  const filePath = resolvePath(outputDir, filename);
-
-  await emitFile(context.program, {
-    path: filePath,
-    content,
-  });
-}
-
-/**
- * Render property name (camelCase).
- */
-function renderPropertyName(prop: PropertyNode): string {
-  return prop.name;
-}
-
-/**
- * Render name in PascalCase.
- */
-function renderName(name: string): string {
-  const pascal = name.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-  return pascal.charAt(0).toUpperCase() + pascal.slice(1);
-}
-
-/**
- * Render TypeScript type for a property.
- */
-function renderType(prop: PropertyNode): string {
-  const baseType = renderSimpleType(prop);
-  return prop.isOptional ? `${baseType} | undefined` : baseType;
-}
-
-/**
- * Render simple TypeScript type without optional modifier.
- */
-function renderSimpleType(prop: PropertyNode): string {
-  let type = prop.isScalar ? typescriptTypeMapper[prop.typeName.name] || "unknown" : prop.typeName.name;
-  if (prop.isDict) {
-    type = "Record<string, unknown>";
-  }
-  type = prop.isCollection ? `${type}[]` : type;
-  return type;
-}
-
-/**
- * Render default value for a property.
- */
-function renderDefault(prop: PropertyNode): string {
-  if (!prop.isOptional) {
-    if (prop.isCollection) {
-      return " = []";
-    } else if (prop.isScalar) {
-      return renderDefaultType(prop.typeName.name, prop.defaultValue);
-    } else if (prop.isDict) {
-      return " = {}";
-    }
-  }
-  return "";
-}
-
-/**
- * Render default value based on type.
- */
-function renderDefaultType(typeName: string, defaultValue: any): string {
-  if (defaultValue !== undefined && defaultValue !== null) {
-    if (typeof defaultValue === "string") {
-      return ` = "${defaultValue}"`;
-    }
-    return ` = ${defaultValue}`;
-  }
-
-  switch (typeName) {
-    case "string":
-      return ' = ""';
-    case "boolean":
-      return " = false";
-    case "number":
-    case "int32":
-    case "int64":
-    case "float32":
-    case "float64":
-    case "integer":
-      return " = 0";
-    default:
-      return "";
-  }
-}
-
-/**
- * Render load property logic.
- */
-function renderLoadProperty(nodes: TypeNode[]) {
-  return (prop: PropertyNode): string => {
-    const propName = prop.name;
-    const varName = `${propName}Value`;
-
-    if (prop.isCollection && !prop.isScalar && !prop.isDict) {
-      return `instance.${propName} = ${prop.typeName.name}.loadCollection(${varName}, context);`;
-    }
-
-    if (prop.isDict) {
-      return `instance.${propName} = ${varName} as Record<string, unknown>;`;
-    }
-
-    if (!prop.isScalar) {
-      return `instance.${propName} = ${prop.typeName.name}.load(${varName} as Record<string, unknown>, context);`;
-    }
-
-    // Scalar types
-    const tsType = typescriptTypeMapper[prop.typeName.name] || "unknown";
-    switch (tsType) {
-      case "string":
-        return `instance.${propName} = String(${varName});`;
-      case "number":
-        return `instance.${propName} = Number(${varName});`;
-      case "boolean":
-        return `instance.${propName} = Boolean(${varName});`;
-      default:
-        return `instance.${propName} = ${varName} as ${tsType};`;
-    }
-  };
-}
-
-/**
- * Render save property logic.
- */
-function renderSaveProperty(prop: PropertyNode): string {
-  const propName = prop.name;
-
-  if (prop.isCollection && !prop.isScalar && !prop.isDict) {
-    return `result["${propName}"] = ${prop.typeName.name}.saveCollection(this.${propName}, context);`;
-  }
-
-  if (!prop.isScalar && !prop.isDict) {
-    return `result["${propName}"] = this.${propName}?.save(context);`;
-  }
-
-  return `result["${propName}"] = this.${propName};`;
-}
diff --git a/schema/emitter/test/declarations.test.ts b/schema/emitter/test/declarations.test.ts
new file mode 100644
index 00000000..d08e05fb
--- /dev/null
+++ b/schema/emitter/test/declarations.test.ts
@@ -0,0 +1,463 @@
+/**
+ * Tests for Declaration IR — lowering pass and property classification.
+ *
+ * Uses Node.js built-in test runner (`node --test`).
+ *
+ * Reuses the same TypeNode/PropertyNode fixtures from expansion.test.ts
+ * to verify that lowerFile(), lowerType(), and classifyProperty() produce
+ * correct Declaration IR from known type graphs.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { Model, ModelProperty } from "@typespec/compiler";
+
+import { TypeRegistry } from "../src/ir/expansion.js";
+import { TypeNode, PropertyNode } from "../src/ir/ast.js";
+import {
+  classifyProperty,
+  lowerFile,
+  lowerType,
+  collectPolymorphicTypeNames,
+} from "../src/ir/lower.js";
+
+// ============================================================================
+// Test fixtures (same as expansion.test.ts)
+// ============================================================================
+
+function makeType(name: string, props: PropertyNode[] = [], opts?: {
+  discriminator?: string;
+  childTypes?: TypeNode[];
+  namespace?: string;
+  base?: { namespace: string; name: string };
+  factories?: Array<{ name: string; sets: Record<string, any>; params: Record<string, string> }>;
+  coercions?: Array<{ scalar: string; expansion: Record<string, any> }>;
+  isAbstract?: boolean;
+  methods?: Array<{ name: string; returns: string; description: string; params?: Record<string, string>; optional?: boolean; sync?: boolean }>;
+}): TypeNode {
+  const node = new TypeNode({} as Model, `Test ${name}`);
+  node.typeName = { namespace: opts?.namespace ?? "Test", name };
+  node.properties = props;
+  node.discriminator = opts?.discriminator;
+  node.childTypes = opts?.childTypes ?? [];
+  node.factories = opts?.factories ?? [];
+  node.coercions = opts?.coercions ?? [];
+  node.isAbstract = opts?.isAbstract ?? false;
+  node.base = opts?.base ?? null;
+  node.methods = (opts?.methods ?? []).map(m => ({ ...m, params: m.params ?? {}, optional: m.optional ?? false, sync: m.sync ?? false }));
+  return node;
+}
+
+function makeProp(name: string, typeName: string, opts?: {
+  isScalar?: boolean;
+  isOptional?: boolean;
+  isCollection?: boolean;
+  isDict?: boolean;
+  type?: TypeNode;
+  defaultValue?: string | number | boolean | null;
+  namespace?: string;
+  allowedValues?: string[];
+}): PropertyNode {
+  const prop = new PropertyNode({} as ModelProperty, `Test ${name}`);
+  prop.name = name;
+  prop.typeName = { namespace: opts?.namespace ?? "Test", name: typeName };
+  prop.isScalar = opts?.isScalar ?? (["string", "boolean", "number", "integer", "int32", "int64", "float", "float32", "float64"].includes(typeName));
+  prop.isOptional = opts?.isOptional ?? false;
+  prop.isCollection = opts?.isCollection ?? false;
+  prop.isDict = opts?.isDict ?? false;
+  prop.type = opts?.type;
+  prop.defaultValue = opts?.defaultValue ?? null;
+  prop.allowedValues = opts?.allowedValues ?? [];
+  return prop;
+}
+
+// -- Shared fixtures --
+
+const textPart = makeType("TextPart", [
+  makeProp("kind", "string", { isScalar: true, defaultValue: "text" }),
+  makeProp("value", "string", { isScalar: true }),
+], { base: { namespace: "Test", name: "ContentPart" } });
+
+const imagePart = makeType("ImagePart", [
+  makeProp("kind", "string", { isScalar: true, defaultValue: "image" }),
+  makeProp("url", "string", { isScalar: true }),
+], { base: { namespace: "Test", name: "ContentPart" } });
+
+const contentPart = makeType("ContentPart", [
+  makeProp("kind", "string", { isScalar: true }),
+], {
+  discriminator: "kind",
+  childTypes: [textPart, imagePart],
+});
+
+// NamedProp for testing collection hasNameProperty
+const namedBinding = makeType("Binding", [
+  makeProp("name", "string", { isScalar: true }),
+  makeProp("value", "string", { isScalar: true }),
+]);
+
+const toolResult = makeType("ToolResult", [
+  makeProp("parts", "ContentPart", { isCollection: true, type: contentPart }),
+], {
+  factories: [
+    { name: "text", sets: { parts: [{ kind: "text", value: "{value}" }] }, params: { value: "string" } },
+  ],
+});
+
+const message = makeType("Message", [
+  makeProp("role", "string", { isScalar: true }),
+  makeProp("parts", "ContentPart", { isCollection: true, type: contentPart }),
+  makeProp("metadata", "dictionary", { isDict: true, isOptional: true }),
+]);
+
+// Type with coercions (shorthand)
+const modelType = makeType("Model", [
+  makeProp("id", "string", { isScalar: true }),
+  makeProp("provider", "string", { isScalar: true, isOptional: true }),
+], {
+  coercions: [{ scalar: "string", expansion: { id: "{value}" } }],
+});
+
+// Abstract polymorphic base (e.g., Connection)
+const apiKeyConnection = makeType("ApiKeyConnection", [
+  makeProp("kind", "string", { isScalar: true, defaultValue: "key" }),
+  makeProp("endpoint", "string", { isScalar: true }),
+  makeProp("apiKey", "string", { isScalar: true, isOptional: true }),
+], { base: { namespace: "Test", name: "Connection" } });
+
+const connectionType = makeType("Connection", [
+  makeProp("kind", "string", { isScalar: true }),
+], {
+  discriminator: "kind",
+  childTypes: [apiKeyConnection],
+  isAbstract: true,
+});
+
+// Type with methods
+const output = makeType("Output", [
+  makeProp("value", "string", { isScalar: true }),
+], {
+  methods: [{ name: "text", returns: "string", description: "Get the text value", optional: false, sync: false }],
+});
+
+// Type with dict, optional complex, and polymorphic ref
+const complexType = makeType("ComplexType", [
+  makeProp("name", "string", { isScalar: true }),
+  makeProp("model", "Model", { type: modelType }),
+  makeProp("tags", "string", { isScalar: true, isCollection: true }),
+  makeProp("bindings", "Binding", { isCollection: true, type: namedBinding }),
+  makeProp("metadata", "dictionary", { isDict: true }),
+  makeProp("content", "ContentPart", { type: contentPart }),
+  makeProp("optModel", "Model", { type: modelType, isOptional: true }),
+]);
+
+function buildTestRegistry(): TypeRegistry {
+  return TypeRegistry.fromTypeGraph([
+    contentPart, textPart, imagePart,
+    toolResult, message, modelType,
+    connectionType, apiKeyConnection,
+    output, namedBinding, complexType,
+  ]);
+}
+
+// ============================================================================
+// classifyProperty tests
+// ============================================================================
+
+describe("classifyProperty", () => {
+  const polyNames = new Set(["ContentPart", "Connection"]);
+
+  it("classifies scalar property", () => {
+    const prop = makeProp("name", "string", { isScalar: true });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "scalar", scalarType: "string" });
+  });
+
+  it("classifies optional scalar property", () => {
+    const prop = makeProp("reason", "string", { isScalar: true, isOptional: true });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "scalar", scalarType: "string" });
+  });
+
+  it("classifies boolean scalar", () => {
+    const prop = makeProp("allowed", "boolean", { isScalar: true });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "scalar", scalarType: "boolean" });
+  });
+
+  it("classifies complex type", () => {
+    const prop = makeProp("model", "Model", { type: modelType });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "complex", typeName: "Model" });
+  });
+
+  it("classifies collection of scalars", () => {
+    const prop = makeProp("tags", "string", { isScalar: true, isCollection: true });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "collection_scalar", scalarType: "string" });
+  });
+
+  it("classifies collection of complex types", () => {
+    const prop = makeProp("parts", "ContentPart", { isCollection: true, type: contentPart });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "collection_complex", typeName: "ContentPart" });
+  });
+
+  it("classifies dict property", () => {
+    const prop = makeProp("metadata", "dictionary", { isDict: true });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "dict" });
+  });
+
+  it("classifies polymorphic reference as complex", () => {
+    // Previously was polymorphic_ref; now all non-scalar non-collection types are "complex"
+    const prop = makeProp("content", "ContentPart", { type: contentPart });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "complex", typeName: "ContentPart" });
+  });
+
+  it("dict takes priority over collection", () => {
+    // A dict+collection combo should be classified as dict
+    const prop = makeProp("extra", "string", { isDict: true, isCollection: true });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "dict" });
+  });
+
+  it("non-polymorphic complex type is classified as complex", () => {
+    const prop = makeProp("model", "Model", { type: modelType });
+    const cat = classifyProperty(prop, polyNames);
+    assert.deepEqual(cat, { kind: "complex", typeName: "Model" });
+  });
+});
+
+// ============================================================================
+// collectPolymorphicTypeNames tests
+// ============================================================================
+
+describe("collectPolymorphicTypeNames", () => {
+  it("finds polymorphic base types", () => {
+    const registry = buildTestRegistry();
+    const names = collectPolymorphicTypeNames(contentPart, registry);
+    assert.ok(names.has("ContentPart"));
+    assert.equal(names.size, 1); // Only ContentPart itself
+  });
+
+  it("returns empty set for non-polymorphic types", () => {
+    const registry = buildTestRegistry();
+    const names = collectPolymorphicTypeNames(modelType, registry);
+    assert.equal(names.size, 0);
+  });
+
+  it("finds polymorphic types through property references", () => {
+    const registry = buildTestRegistry();
+    const names = collectPolymorphicTypeNames(message, registry);
+    assert.ok(names.has("ContentPart"));
+  });
+});
+
+// ============================================================================
+// lowerType tests
+// ============================================================================
+
+describe("lowerType", () => {
+  const registry = buildTestRegistry();
+  const polyNames = new Set(["ContentPart", "Connection"]);
+
+  it("lowers a simple type with scalar fields", () => {
+    const decl = lowerType(modelType, registry, polyNames);
+    assert.equal(decl.typeName.name, "Model");
+    assert.equal(decl.isAbstract, false);
+    assert.equal(decl.base, null);
+    assert.equal(decl.fields.length, 2);
+    assert.equal(decl.fields[0].name, "id");
+    assert.deepEqual(decl.fields[0].category, { kind: "scalar", scalarType: "string" });
+    assert.equal(decl.fields[1].name, "provider");
+    assert.equal(decl.fields[1].isOptional, true);
+  });
+
+  it("detects coercion property", () => {
+    const decl = lowerType(modelType, registry, polyNames);
+    assert.equal(decl.coercionProperty, "id");
+  });
+
+  it("lowers coercions in load method", () => {
+    const decl = lowerType(modelType, registry, polyNames);
+    assert.equal(decl.load.coercions.length, 1);
+    assert.equal(decl.load.coercions[0].scalarType, "string");
+    assert.equal(decl.load.coercions[0].assignments.length, 1);
+    assert.equal(decl.load.coercions[0].assignments[0].fieldName, "id");
+    assert.equal(decl.load.coercions[0].assignments[0].isInput, true);
+  });
+
+  it("lowers a type with complex collection", () => {
+    const decl = lowerType(message, registry, polyNames);
+    assert.equal(decl.fields.length, 3);
+    // parts is collection_complex
+    assert.deepEqual(decl.fields[1].category, { kind: "collection_complex", typeName: "ContentPart" });
+    // metadata is dict
+    assert.deepEqual(decl.fields[2].category, { kind: "dict" });
+    // Should have a collection helper for parts
+    assert.equal(decl.collectionHelpers.length, 1);
+    assert.equal(decl.collectionHelpers[0].propertyName, "parts");
+  });
+
+  it("lowers polymorphic dispatch", () => {
+    const decl = lowerType(contentPart, registry, polyNames);
+    assert.ok(decl.polymorphicDispatch);
+    assert.equal(decl.polymorphicDispatch!.discriminatorField, "kind");
+    assert.equal(decl.polymorphicDispatch!.variants.length, 2);
+    assert.equal(decl.polymorphicDispatch!.variants[0].value, "text");
+    assert.equal(decl.polymorphicDispatch!.variants[0].typeName.name, "TextPart");
+    assert.equal(decl.polymorphicDispatch!.variants[1].value, "image");
+  });
+
+  it("lowers abstract polymorphic base", () => {
+    const decl = lowerType(connectionType, registry, polyNames);
+    assert.ok(decl.polymorphicDispatch);
+    assert.equal(decl.polymorphicDispatch!.isAbstract, true);
+    assert.equal(decl.polymorphicDispatch!.variants.length, 1);
+    assert.equal(decl.polymorphicDispatch!.variants[0].value, "key");
+  });
+
+  it("lowers non-abstract polymorphic base with default", () => {
+    const decl = lowerType(contentPart, registry, polyNames);
+    assert.ok(decl.polymorphicDispatch);
+    assert.ok(decl.polymorphicDispatch!.defaultVariant);
+    assert.equal(decl.polymorphicDispatch!.defaultVariant!.isSelfReference, true);
+  });
+
+  it("lowers factory methods", () => {
+    const decl = lowerType(toolResult, registry, polyNames);
+    assert.equal(decl.factories.length, 1);
+    assert.equal(decl.factories[0].name, "text");
+    assert.deepEqual(decl.factories[0].params, { value: "string" });
+    assert.equal(decl.factories[0].body.kind, "construct");
+  });
+
+  it("factory name is always the canonical name (no collision avoidance in IR)", () => {
+    // Collision avoidance is language-specific — the IR stores the canonical name.
+    // Python adds create_ prefix in its emitter; TS/Rust/C#/Go use name directly.
+    const conflictType = makeType("Conflict", [
+      makeProp("text", "string", { isScalar: true }),
+    ], {
+      factories: [
+        { name: "text", sets: { text: "{val}" }, params: { val: "string" } },
+      ],
+    });
+    const conflictRegistry = TypeRegistry.fromTypeGraph([conflictType]);
+    const decl = lowerType(conflictType, conflictRegistry, new Set());
+    assert.equal(decl.factories[0].name, "text");
+  });
+
+  it("lowers method stubs", () => {
+    const decl = lowerType(output, registry, polyNames);
+    assert.equal(decl.methods.length, 1);
+    assert.equal(decl.methods[0].name, "text");
+    assert.equal(decl.methods[0].returns, "string");
+  });
+
+  it("lowers collection helper with name property detection", () => {
+    const typeWithNamedCollection = makeType("Container", [
+      makeProp("bindings", "Binding", { isCollection: true, type: namedBinding }),
+    ]);
+    const decl = lowerType(typeWithNamedCollection, registry, polyNames);
+    assert.equal(decl.collectionHelpers.length, 1);
+    assert.equal(decl.collectionHelpers[0].hasNameProperty, true);
+    assert.deepEqual(decl.collectionHelpers[0].innerFields, ["value"]); // "name" excluded
+  });
+
+  it("lowers load assignments for all property categories", () => {
+    const decl = lowerType(complexType, registry, polyNames);
+    const cats = decl.load.assignments.map(a => a.category.kind);
+    assert.ok(cats.includes("scalar")); // name
+    assert.ok(cats.includes("complex")); // model
+    assert.ok(cats.includes("collection_scalar")); // tags
+    assert.ok(cats.includes("collection_complex")); // bindings
+    assert.ok(cats.includes("dict")); // metadata
+    assert.ok(cats.includes("complex")); // content (was polymorphic_ref, now just complex)
+  });
+
+  it("lowers save assignments matching load assignments", () => {
+    const decl = lowerType(complexType, registry, polyNames);
+    assert.equal(decl.save.assignments.length, decl.load.assignments.length);
+    // Save categories should match load categories
+    for (let i = 0; i < decl.save.assignments.length; i++) {
+      assert.deepEqual(
+        decl.save.assignments[i].category,
+        decl.load.assignments[i].category,
+      );
+    }
+  });
+
+  it("sets hasBase correctly for child types", () => {
+    const decl = lowerType(textPart, registry, polyNames);
+    assert.equal(decl.save.hasBase, true);
+    assert.equal(decl.base?.name, "ContentPart");
+  });
+
+  it("sets hasBase to false for root types", () => {
+    const decl = lowerType(modelType, registry, polyNames);
+    assert.equal(decl.save.hasBase, false);
+  });
+});
+
+// ============================================================================
+// lowerFile tests
+// ============================================================================
+
+describe("lowerFile", () => {
+  const registry = buildTestRegistry();
+  const polyNames = new Set(["ContentPart", "Connection"]);
+
+  it("lowers a simple file with one type", () => {
+    const file = lowerFile(modelType, registry, polyNames);
+    assert.equal(file.typeName.name, "Model");
+    assert.equal(file.types.length, 1);
+    assert.equal(file.containsAbstract, false);
+  });
+
+  it("lowers a polymorphic file with parent + children", () => {
+    const file = lowerFile(contentPart, registry, polyNames);
+    assert.equal(file.typeName.name, "ContentPart");
+    assert.equal(file.types.length, 3); // ContentPart + TextPart + ImagePart
+    assert.equal(file.types[0].typeName.name, "ContentPart");
+    assert.equal(file.types[1].typeName.name, "TextPart");
+    assert.equal(file.types[2].typeName.name, "ImagePart");
+  });
+
+  it("marks containsAbstract when base is abstract", () => {
+    const file = lowerFile(connectionType, registry, polyNames);
+    assert.equal(file.containsAbstract, true);
+  });
+
+  it("resolves imports excluding types defined in file", () => {
+    const file = lowerFile(contentPart, registry, polyNames);
+    // ContentPart, TextPart, ImagePart are all in this file — no self-imports
+    const importNames = file.imports.flatMap(i => i.names);
+    assert.ok(!importNames.includes("ContentPart"));
+    assert.ok(!importNames.includes("TextPart"));
+    assert.ok(!importNames.includes("ImagePart"));
+  });
+
+  it("resolves factory-referenced imports", () => {
+    const file = lowerFile(toolResult, registry, polyNames);
+    // ToolResult.text factory references TextPart and ContentPart
+    const importNames = file.imports.flatMap(i => i.names);
+    assert.ok(importNames.includes("TextPart"));
+  });
+
+  it("groups imports by module", () => {
+    const file = lowerFile(toolResult, registry, polyNames);
+    // TextPart should be imported from ContentPart module
+    const contentImport = file.imports.find(i => i.module === "ContentPart");
+    assert.ok(contentImport);
+    assert.ok(contentImport!.names.includes("TextPart"));
+  });
+
+  it("produces identical IR regardless of eventual target language", () => {
+    // The IR is language-agnostic — same input always produces same output
+    const file1 = lowerFile(modelType, registry, polyNames);
+    const file2 = lowerFile(modelType, registry, polyNames);
+    assert.deepEqual(file1, file2);
+  });
+});
diff --git a/schema/emitter/test/expansion.test.ts b/schema/emitter/test/expansion.test.ts
new file mode 100644
index 00000000..4b38a443
--- /dev/null
+++ b/schema/emitter/test/expansion.test.ts
@@ -0,0 +1,1009 @@
+/**
+ * Tests for Expression IR — resolver and per-language visitors.
+ *
+ * Uses Node.js built-in test runner (`node --test`).
+ *
+ * Test organization:
+ *   1. Type graph fixtures (TypeNode/PropertyNode construction)
+ *   2. Resolver tests (resolveFactoryExpr, resolveCoerceExpr)
+ *   3. Visitor tests (one suite per language × expr kind)
+ *   4. Integration tests (resolve → render, verified against known output)
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { Model, ModelProperty } from "@typespec/compiler";
+
+import {
+  TypeRegistry,
+  resolveFactoryExpr,
+  resolveCoerceExpr,
+  Expr,
+} from "../src/ir/expansion.js";
+import { RustExprVisitor } from "../src/languages/rust/visitor.js";
+import { TypeScriptExprVisitor } from "../src/languages/typescript/visitor.js";
+import { PythonExprVisitor } from "../src/languages/python/visitor.js";
+import { CSharpExprVisitor } from "../src/languages/csharp/visitor.js";
+import { GoExprVisitor } from "../src/languages/go/visitor.js";
+import { ExprVisitor } from "../src/ir/visitor.js";
+import { TypeNode, PropertyNode, TypeName } from "../src/ir/ast.js";
+
+// Local visitor lookup — replaces the old getVisitor() from render-expr.ts
+const visitors: Record<string, (registry?: TypeRegistry) => ExprVisitor> = {
+  rust: (r) => new RustExprVisitor(r),
+  typescript: (r) => new TypeScriptExprVisitor(r),
+  python: (r) => new PythonExprVisitor(r),
+  csharp: (r) => new CSharpExprVisitor(r),
+  go: (r) => new GoExprVisitor(r),
+};
+function getVisitor(lang: string, registry?: TypeRegistry): ExprVisitor {
+  const factory = visitors[lang];
+  if (!factory) throw new Error(`No ExprVisitor for language '${lang}'.`);
+  return factory(registry);
+}
+
+// ============================================================================
+// Test fixtures — minimal TypeNode/PropertyNode construction
+// ============================================================================
+
+/** Create a minimal TypeNode for testing. */
+function makeType(name: string, props: PropertyNode[] = [], opts?: {
+  discriminator?: string;
+  childTypes?: TypeNode[];
+  namespace?: string;
+  factories?: Array<{ name: string; sets: Record<string, any>; params: Record<string, string> }>;
+}): TypeNode {
+  const node = new TypeNode({} as Model, `Test ${name}`);
+  node.typeName = { namespace: opts?.namespace ?? "Test", name };
+  node.properties = props;
+  node.discriminator = opts?.discriminator;
+  node.childTypes = opts?.childTypes ?? [];
+  node.factories = opts?.factories ?? [];
+  return node;
+}
+
+/** Create a minimal PropertyNode for testing. */
+function makeProp(name: string, typeName: string, opts?: {
+  isScalar?: boolean;
+  isOptional?: boolean;
+  isCollection?: boolean;
+  isDict?: boolean;
+  type?: TypeNode;
+  defaultValue?: string | number | boolean | null;
+  namespace?: string;
+}): PropertyNode {
+  const prop = new PropertyNode({} as ModelProperty, `Test ${name}`);
+  prop.name = name;
+  prop.typeName = { namespace: opts?.namespace ?? "Test", name: typeName };
+  prop.isScalar = opts?.isScalar ?? (["string", "boolean", "number", "integer", "int32", "int64", "float", "float32", "float64"].includes(typeName));
+  prop.isOptional = opts?.isOptional ?? false;
+  prop.isCollection = opts?.isCollection ?? false;
+  prop.isDict = opts?.isDict ?? false;
+  prop.type = opts?.type;
+  prop.defaultValue = opts?.defaultValue ?? null;
+  return prop;
+}
+
+// ---- Shared type graph fixtures ----
+
+// GuardrailResult: { allowed: boolean, reason?: string, rewrite?: unknown }
+const guardrailResult = makeType("GuardrailResult", [
+  makeProp("allowed", "boolean", { isScalar: true }),
+  makeProp("reason", "string", { isScalar: true, isOptional: true }),
+  makeProp("rewrite", "any", { isScalar: true, isOptional: true }),
+]);
+
+// TextPart: { value: string } (child of ContentPart)
+const textPart = makeType("TextPart", [
+  makeProp("kind", "string", { isScalar: true, defaultValue: "text" }),
+  makeProp("value", "string", { isScalar: true }),
+]);
+
+// ImagePart: { url: string } (child of ContentPart)
+const imagePart = makeType("ImagePart", [
+  makeProp("kind", "string", { isScalar: true, defaultValue: "image" }),
+  makeProp("url", "string", { isScalar: true }),
+]);
+
+// ContentPart: discriminated union with "kind" field
+const contentPart = makeType("ContentPart", [
+  makeProp("kind", "string", { isScalar: true }),
+], {
+  discriminator: "kind",
+  childTypes: [textPart, imagePart],
+});
+
+// ToolResult: { parts: ContentPart[] }
+const toolResult = makeType("ToolResult", [
+  makeProp("parts", "ContentPart", { isCollection: true, type: contentPart }),
+]);
+
+// Message: { role: string, parts: ContentPart[] }
+const message = makeType("Message", [
+  makeProp("role", "string", { isScalar: true }),
+  makeProp("parts", "ContentPart", { isCollection: true, type: contentPart }),
+]);
+
+// Model (simple, non-polymorphic): { id: string, provider: string }
+const modelType = makeType("Model", [
+  makeProp("id", "string", { isScalar: true }),
+  makeProp("provider", "string", { isScalar: true }),
+]);
+
+function buildTestRegistry(): TypeRegistry {
+  return TypeRegistry.fromTypeGraph([
+    guardrailResult, contentPart, textPart, imagePart, toolResult, message, modelType,
+  ]);
+}
+
+// ============================================================================
+// TypeRegistry tests
+// ============================================================================
+
+describe("TypeRegistry", () => {
+  it("registers and looks up types by name", () => {
+    const registry = new TypeRegistry();
+    registry.register(guardrailResult);
+    assert.equal(registry.get("GuardrailResult"), guardrailResult);
+    assert.equal(registry.get("NonExistent"), undefined);
+  });
+
+  it("fromTypeGraph walks the full type graph", () => {
+    const registry = buildTestRegistry();
+    assert.ok(registry.get("GuardrailResult"));
+    assert.ok(registry.get("ContentPart"));
+    assert.ok(registry.get("TextPart"));
+    assert.ok(registry.get("ImagePart"));
+    assert.ok(registry.get("ToolResult"));
+    assert.ok(registry.get("Message"));
+    assert.ok(registry.get("Model"));
+  });
+
+  it("handles cycles gracefully (same type reachable multiple ways)", () => {
+    const registry = TypeRegistry.fromTypeGraph([toolResult, contentPart]);
+    assert.ok(registry.get("ToolResult"));
+    assert.ok(registry.get("ContentPart"));
+    assert.ok(registry.get("TextPart"));
+  });
+});
+
+// ============================================================================
+// Resolver tests — resolveFactoryExpr
+// ============================================================================
+
+describe("resolveFactoryExpr", () => {
+  const registry = buildTestRegistry();
+
+  it("resolves a simple boolean set (GuardrailResult.allow)", () => {
+    const expr = resolveFactoryExpr(
+      { allowed: true },
+      {},
+      guardrailResult,
+      registry,
+    );
+    assert.equal(expr.kind, "construct");
+    assert.equal(expr.typeName.name, "GuardrailResult");
+    assert.equal(expr.fields.length, 1);
+    assert.deepStrictEqual(expr.fields[0], {
+      propertyName: "allowed",
+      value: { kind: "boolean", value: true },
+      isOptional: false,
+    });
+  });
+
+  it("resolves sets + params (GuardrailResult.deny)", () => {
+    const expr = resolveFactoryExpr(
+      { allowed: false },
+      { reason: "string" },
+      guardrailResult,
+      registry,
+    );
+    assert.equal(expr.kind, "construct");
+    assert.equal(expr.fields.length, 2);
+    // allowed = false
+    assert.deepStrictEqual(expr.fields[0], {
+      propertyName: "allowed",
+      value: { kind: "boolean", value: false },
+      isOptional: false,
+    });
+    // reason = ParamRef (optional field!)
+    assert.deepStrictEqual(expr.fields[1], {
+      propertyName: "reason",
+      value: { kind: "param", name: "reason", paramType: "string" },
+      isOptional: true,
+    });
+  });
+
+  it("resolves factory with no sets and no params (empty constructor)", () => {
+    const expr = resolveFactoryExpr({}, {}, guardrailResult, registry);
+    assert.equal(expr.kind, "construct");
+    assert.equal(expr.fields.length, 0);
+  });
+
+  it("resolves string literal set values", () => {
+    const expr = resolveFactoryExpr(
+      { role: "user" },
+      {},
+      message,
+      registry,
+    );
+    assert.equal(expr.fields.length, 1);
+    assert.deepStrictEqual(expr.fields[0].value, { kind: "string", value: "user" });
+  });
+
+  it("resolves number literal set values", () => {
+    const numType = makeType("NumType", [makeProp("count", "number", { isScalar: true })]);
+    const expr = resolveFactoryExpr({ count: 42 }, {}, numType, registry);
+    assert.deepStrictEqual(expr.fields[0].value, { kind: "number", value: 42 });
+  });
+
+  it("resolves param placeholders inside sets", () => {
+    const expr = resolveFactoryExpr(
+      { role: "{role}" },
+      { role: "string" },
+      message,
+      registry,
+    );
+    assert.equal(expr.fields.length, 1);
+    assert.deepStrictEqual(expr.fields[0].value, {
+      kind: "param", name: "role", paramType: "string",
+    });
+  });
+
+  it("does not double-emit params consumed as nested placeholders", () => {
+    // If "role" is both a param and used as {role} inside sets, it should only appear once
+    const expr = resolveFactoryExpr(
+      { role: "{role}" },
+      { role: "string" },
+      message,
+      registry,
+    );
+    // Should have exactly 1 field (role), not 2
+    assert.equal(expr.fields.length, 1);
+  });
+
+  it("resolves nested array with variant objects", () => {
+    const expr = resolveFactoryExpr(
+      { parts: [{ kind: "text", value: "{val}" }] },
+      { val: "string" },
+      toolResult,
+      registry,
+    );
+    assert.equal(expr.kind, "construct");
+    assert.equal(expr.fields.length, 1);
+    const partsField = expr.fields[0];
+    assert.equal(partsField.propertyName, "parts");
+    assert.equal(partsField.value.kind, "array");
+
+    if (partsField.value.kind === "array") {
+      assert.equal(partsField.value.items.length, 1);
+      const item = partsField.value.items[0];
+      assert.equal(item.kind, "variant");
+      if (item.kind === "variant") {
+        assert.equal(item.baseTypeName.name, "ContentPart");
+        assert.equal(item.discriminatorValue, "text");
+        assert.equal(item.variantTypeName.name, "TextPart");
+        assert.equal(item.fields.length, 1);
+        assert.equal(item.fields[0].propertyName, "value");
+        assert.equal(item.fields[0].isOptional, false);
+        assert.deepStrictEqual(item.fields[0].value, {
+          kind: "param", name: "val", paramType: "string",
+        });
+      }
+    }
+  });
+
+  it("throws for unknown property in sets", () => {
+    assert.throws(
+      () => resolveFactoryExpr({ unknown: true }, {}, guardrailResult, registry),
+      /Property 'unknown' not found on type 'GuardrailResult'/,
+    );
+  });
+
+  it("throws for param not matching any property", () => {
+    assert.throws(
+      () => resolveFactoryExpr({}, { badParam: "string" }, guardrailResult, registry),
+      /Parameter 'badParam' does not match any property/,
+    );
+  });
+
+  it("throws for unresolved param placeholder", () => {
+    assert.throws(
+      () => resolveFactoryExpr({ role: "{unknown}" }, { other: "string" }, message, registry),
+      /Placeholder '\{unknown\}' does not match any declared parameter/,
+    );
+  });
+
+  it("throws for unknown discriminator value", () => {
+    assert.throws(
+      () => resolveFactoryExpr(
+        { parts: [{ kind: "unknown_type", value: "x" }] },
+        {},
+        toolResult,
+        registry,
+      ),
+      /No child type of 'ContentPart' has kind='unknown_type'/,
+    );
+  });
+});
+
+// ============================================================================
+// Resolver tests — resolveCoerceExpr
+// ============================================================================
+
+describe("resolveCoerceExpr", () => {
+  const registry = buildTestRegistry();
+
+  it("resolves a simple coercion (Model with id coercion)", () => {
+    const expr = resolveCoerceExpr(
+      { id: "{value}" },
+      "string",
+      modelType,
+      registry,
+    );
+    assert.equal(expr.kind, "construct");
+    assert.equal(expr.typeName.name, "Model");
+    assert.equal(expr.fields.length, 1);
+    assert.deepStrictEqual(expr.fields[0], {
+      propertyName: "id",
+      value: { kind: "param", name: "value", paramType: "string" },
+      isOptional: false,
+    });
+  });
+
+  it("resolves a coercion with mixed literal and param", () => {
+    const expr = resolveCoerceExpr(
+      { role: "system", parts: "{value}" },
+      "string",
+      message,
+      registry,
+    );
+    assert.equal(expr.fields.length, 2);
+    assert.deepStrictEqual(expr.fields[0].value, { kind: "string", value: "system" });
+    assert.deepStrictEqual(expr.fields[1].value, {
+      kind: "param", name: "value", paramType: "string",
+    });
+  });
+});
+
+// ============================================================================
+// Visitor tests — Rust
+// ============================================================================
+
+describe("RustExprVisitor", () => {
+  const v = new RustExprVisitor();
+
+  it("renders string literal", () => {
+    assert.equal(v.visitExpr({ kind: "string", value: "hello" }), '"hello".to_string()');
+  });
+
+  it("renders number literal", () => {
+    assert.equal(v.visitExpr({ kind: "number", value: 42 }), "42");
+  });
+
+  it("renders boolean literal", () => {
+    assert.equal(v.visitExpr({ kind: "boolean", value: true }), "true");
+    assert.equal(v.visitExpr({ kind: "boolean", value: false }), "false");
+  });
+
+  it("renders null literal", () => {
+    assert.equal(v.visitExpr({ kind: "null" }), "None");
+  });
+
+  it("renders string param ref with .into()", () => {
+    assert.equal(
+      v.visitExpr({ kind: "param", name: "reason", paramType: "string" }),
+      "reason.into()",
+    );
+  });
+
+  it("renders non-string param ref with .into()", () => {
+    assert.equal(
+      v.visitExpr({ kind: "param", name: "count", paramType: "integer" }),
+      "count.into()",
+    );
+  });
+
+  it("renders camelCase param as snake_case with .into()", () => {
+    assert.equal(
+      v.visitExpr({ kind: "param", name: "maxTokens", paramType: "integer" }),
+      "max_tokens.into()",
+    );
+  });
+
+  it("renders Construct", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [
+        { propertyName: "allowed", value: { kind: "boolean", value: true }, isOptional: false },
+      ],
+    };
+    assert.equal(v.visitExpr(expr), "GuardrailResult { allowed: true, ..Default::default() }");
+  });
+
+  it("renders empty Construct with only default", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [],
+    };
+    assert.equal(v.visitExpr(expr), "GuardrailResult { ..Default::default() }");
+  });
+
+  it("renders optional field with Some() wrapper", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [
+        { propertyName: "allowed", value: { kind: "boolean", value: false }, isOptional: false },
+        { propertyName: "reason", value: { kind: "param", name: "reason", paramType: "string" }, isOptional: true },
+      ],
+    };
+    assert.equal(
+      v.visitExpr(expr),
+      "GuardrailResult { allowed: false, reason: Some(reason.into()), ..Default::default() }",
+    );
+  });
+
+  it("renders VariantConstruct", () => {
+    const expr: Expr = {
+      kind: "variant",
+      baseTypeName: { namespace: "Test", name: "ContentPart" },
+      discriminator: "kind",
+      discriminatorValue: "text",
+      variantTypeName: { namespace: "Test", name: "TextPart" },
+      fields: [
+        { propertyName: "value", value: { kind: "param", name: "val", paramType: "string" }, isOptional: false },
+      ],
+    };
+    assert.equal(
+      v.visitExpr(expr),
+      "ContentPart { kind: ContentPartKind::TextPart { value: val.into() }, ..Default::default() }",
+    );
+  });
+
+  it("renders ArrayLiteral", () => {
+    const expr: Expr = {
+      kind: "array",
+      elementTypeName: { namespace: "Test", name: "ContentPart" },
+      items: [{ kind: "string", value: "hello" }],
+    };
+    assert.equal(v.visitExpr(expr), 'vec!["hello".to_string()]');
+  });
+
+  it("renders empty ArrayLiteral", () => {
+    const expr: Expr = {
+      kind: "array",
+      elementTypeName: { namespace: "Test", name: "ContentPart" },
+      items: [],
+    };
+    assert.equal(v.visitExpr(expr), "vec![]");
+  });
+
+  it("renders snake_case field names in constructs", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "Model" },
+      fields: [
+        { propertyName: "apiType", value: { kind: "string", value: "chat" }, isOptional: false },
+      ],
+    };
+    assert.equal(v.visitExpr(expr), 'Model { api_type: "chat".to_string(), ..Default::default() }');
+  });
+});
+
+// ============================================================================
+// Visitor tests — TypeScript
+// ============================================================================
+
+describe("TypeScriptExprVisitor", () => {
+  const v = new TypeScriptExprVisitor();
+
+  it("renders string literal", () => {
+    assert.equal(v.visitExpr({ kind: "string", value: "hello" }), '"hello"');
+  });
+
+  it("renders boolean literal", () => {
+    assert.equal(v.visitExpr({ kind: "boolean", value: true }), "true");
+    assert.equal(v.visitExpr({ kind: "boolean", value: false }), "false");
+  });
+
+  it("renders null as undefined", () => {
+    assert.equal(v.visitExpr({ kind: "null" }), "undefined");
+  });
+
+  it("renders param ref as camelCase (unchanged)", () => {
+    assert.equal(
+      v.visitExpr({ kind: "param", name: "reason", paramType: "string" }),
+      "reason",
+    );
+  });
+
+  it("renders Construct", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [
+        { propertyName: "allowed", value: { kind: "boolean", value: true }, isOptional: false },
+      ],
+    };
+    assert.equal(v.visitExpr(expr), "new GuardrailResult({ allowed: true })");
+  });
+
+  it("renders empty Construct", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [],
+    };
+    assert.equal(v.visitExpr(expr), "new GuardrailResult({})");
+  });
+
+  it("renders VariantConstruct as child class construction", () => {
+    const expr: Expr = {
+      kind: "variant",
+      baseTypeName: { namespace: "Test", name: "ContentPart" },
+      discriminator: "kind",
+      discriminatorValue: "text",
+      variantTypeName: { namespace: "Test", name: "TextPart" },
+      fields: [
+        { propertyName: "value", value: { kind: "param", name: "val", paramType: "string" }, isOptional: false },
+      ],
+    };
+    assert.equal(v.visitExpr(expr), "new TextPart({ value: val })");
+  });
+
+  it("renders ArrayLiteral", () => {
+    const expr: Expr = {
+      kind: "array",
+      elementTypeName: { namespace: "Test", name: "string" },
+      items: [{ kind: "string", value: "a" }, { kind: "string", value: "b" }],
+    };
+    assert.equal(v.visitExpr(expr), '["a", "b"]');
+  });
+});
+
+// ============================================================================
+// Visitor tests — Python
+// ============================================================================
+
+describe("PythonExprVisitor", () => {
+  const v = new PythonExprVisitor();
+
+  it("renders string literal", () => {
+    assert.equal(v.visitExpr({ kind: "string", value: "hello" }), '"hello"');
+  });
+
+  it("renders boolean with capital letters", () => {
+    assert.equal(v.visitExpr({ kind: "boolean", value: true }), "True");
+    assert.equal(v.visitExpr({ kind: "boolean", value: false }), "False");
+  });
+
+  it("renders null as None", () => {
+    assert.equal(v.visitExpr({ kind: "null" }), "None");
+  });
+
+  it("renders param ref as snake_case", () => {
+    assert.equal(
+      v.visitExpr({ kind: "param", name: "maxTokens", paramType: "integer" }),
+      "max_tokens",
+    );
+  });
+
+  it("renders Construct with snake_case fields", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [
+        { propertyName: "allowed", value: { kind: "boolean", value: true }, isOptional: false },
+      ],
+    };
+    assert.equal(v.visitExpr(expr), "GuardrailResult(allowed=True)");
+  });
+
+  it("renders VariantConstruct", () => {
+    const expr: Expr = {
+      kind: "variant",
+      baseTypeName: { namespace: "Test", name: "ContentPart" },
+      discriminator: "kind",
+      discriminatorValue: "text",
+      variantTypeName: { namespace: "Test", name: "TextPart" },
+      fields: [
+        { propertyName: "value", value: { kind: "param", name: "val", paramType: "string" }, isOptional: false },
+      ],
+    };
+    assert.equal(v.visitExpr(expr), "TextPart(value=val)");
+  });
+
+  it("renders ArrayLiteral", () => {
+    const expr: Expr = {
+      kind: "array",
+      elementTypeName: { namespace: "Test", name: "string" },
+      items: [{ kind: "string", value: "a" }],
+    };
+    assert.equal(v.visitExpr(expr), '["a"]');
+  });
+});
+
+// ============================================================================
+// Visitor tests — C#
+// ============================================================================
+
+describe("CSharpExprVisitor", () => {
+  const v = new CSharpExprVisitor();
+
+  it("renders string literal", () => {
+    assert.equal(v.visitExpr({ kind: "string", value: "hello" }), '"hello"');
+  });
+
+  it("renders boolean lowercase", () => {
+    assert.equal(v.visitExpr({ kind: "boolean", value: true }), "true");
+  });
+
+  it("renders null", () => {
+    assert.equal(v.visitExpr({ kind: "null" }), "null");
+  });
+
+  it("renders Construct with PascalCase fields", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [
+        { propertyName: "allowed", value: { kind: "boolean", value: true }, isOptional: false },
+      ],
+    };
+    assert.equal(v.visitExpr(expr), "new GuardrailResult { Allowed = true }");
+  });
+
+  it("renders empty Construct", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [],
+    };
+    assert.equal(v.visitExpr(expr), "new GuardrailResult()");
+  });
+
+  it("renders VariantConstruct with PascalCase", () => {
+    const expr: Expr = {
+      kind: "variant",
+      baseTypeName: { namespace: "Test", name: "ContentPart" },
+      discriminator: "kind",
+      discriminatorValue: "text",
+      variantTypeName: { namespace: "Test", name: "TextPart" },
+      fields: [
+        { propertyName: "value", value: { kind: "param", name: "val", paramType: "string" }, isOptional: false },
+      ],
+    };
+    assert.equal(v.visitExpr(expr), "new TextPart { Value = val }");
+  });
+
+  it("renders ArrayLiteral with explicit type", () => {
+    const expr: Expr = {
+      kind: "array",
+      elementTypeName: { namespace: "Test", name: "ContentPart" },
+      items: [{ kind: "string", value: "a" }],
+    };
+    assert.equal(v.visitExpr(expr), 'new List<ContentPart> { "a" }');
+  });
+});
+
+// ============================================================================
+// Visitor tests — Go
+// ============================================================================
+
+describe("GoExprVisitor", () => {
+  const v = new GoExprVisitor();
+
+  it("renders string literal", () => {
+    assert.equal(v.visitExpr({ kind: "string", value: "hello" }), '"hello"');
+  });
+
+  it("renders boolean", () => {
+    assert.equal(v.visitExpr({ kind: "boolean", value: true }), "true");
+  });
+
+  it("renders null as nil", () => {
+    assert.equal(v.visitExpr({ kind: "null" }), "nil");
+  });
+
+  it("renders Construct with PascalCase fields", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [
+        { propertyName: "allowed", value: { kind: "boolean", value: true }, isOptional: false },
+      ],
+    };
+    assert.equal(v.visitExpr(expr), "GuardrailResult{ Allowed: true }");
+  });
+
+  it("renders ArrayLiteral with type prefix", () => {
+    const expr: Expr = {
+      kind: "array",
+      elementTypeName: { namespace: "Test", name: "ContentPart" },
+      items: [{ kind: "string", value: "a" }],
+    };
+    assert.equal(v.visitExpr(expr), '[]ContentPart{"a"}');
+  });
+
+  it("renders empty struct", () => {
+    const expr: Expr = {
+      kind: "construct",
+      typeName: { namespace: "Test", name: "GuardrailResult" },
+      fields: [],
+    };
+    assert.equal(v.visitExpr(expr), "GuardrailResult{}");
+  });
+});
+
+// ============================================================================
+// getVisitor registry tests
+// ============================================================================
+
+describe("getVisitor", () => {
+  it("returns visitors for all supported languages", () => {
+    for (const lang of ["rust", "typescript", "python", "csharp", "go"]) {
+      const visitor = getVisitor(lang);
+      assert.ok(visitor, `No visitor for ${lang}`);
+      // Smoke test — every visitor can render a string literal
+      assert.equal(typeof visitor.visitExpr({ kind: "string", value: "x" }), "string");
+    }
+  });
+
+  it("throws for unknown language", () => {
+    assert.throws(
+      () => getVisitor("java"),
+      /No ExprVisitor for language 'java'/,
+    );
+  });
+});
+
+// ============================================================================
+// Integration tests — resolve → render, verified against known output
+// ============================================================================
+
+describe("Integration: GuardrailResult factories", () => {
+  const registry = buildTestRegistry();
+
+  it("allow() → Rust", () => {
+    const expr = resolveFactoryExpr({ allowed: true }, {}, guardrailResult, registry);
+    const code = new RustExprVisitor().visitExpr(expr);
+    assert.equal(code, "GuardrailResult { allowed: true, ..Default::default() }");
+  });
+
+  it("allow() → TypeScript", () => {
+    const expr = resolveFactoryExpr({ allowed: true }, {}, guardrailResult, registry);
+    const code = new TypeScriptExprVisitor().visitExpr(expr);
+    assert.equal(code, "new GuardrailResult({ allowed: true })");
+  });
+
+  it("allow() → Python", () => {
+    const expr = resolveFactoryExpr({ allowed: true }, {}, guardrailResult, registry);
+    const code = new PythonExprVisitor().visitExpr(expr);
+    assert.equal(code, "GuardrailResult(allowed=True)");
+  });
+
+  it("allow() → C#", () => {
+    const expr = resolveFactoryExpr({ allowed: true }, {}, guardrailResult, registry);
+    const code = new CSharpExprVisitor().visitExpr(expr);
+    assert.equal(code, "new GuardrailResult { Allowed = true }");
+  });
+
+  it("deny(reason) → Rust", () => {
+    const expr = resolveFactoryExpr({ allowed: false }, { reason: "string" }, guardrailResult, registry);
+    const code = new RustExprVisitor().visitExpr(expr);
+    assert.equal(code, "GuardrailResult { allowed: false, reason: Some(reason.into()), ..Default::default() }");
+  });
+
+  it("deny(reason) → TypeScript", () => {
+    const expr = resolveFactoryExpr({ allowed: false }, { reason: "string" }, guardrailResult, registry);
+    const code = new TypeScriptExprVisitor().visitExpr(expr);
+    assert.equal(code, "new GuardrailResult({ allowed: false, reason: reason })");
+  });
+
+  it("deny(reason) → Python", () => {
+    const expr = resolveFactoryExpr({ allowed: false }, { reason: "string" }, guardrailResult, registry);
+    const code = new PythonExprVisitor().visitExpr(expr);
+    assert.equal(code, "GuardrailResult(allowed=False, reason=reason)");
+  });
+
+  it("deny(reason) → C#", () => {
+    const expr = resolveFactoryExpr({ allowed: false }, { reason: "string" }, guardrailResult, registry);
+    const code = new CSharpExprVisitor().visitExpr(expr);
+    assert.equal(code, "new GuardrailResult { Allowed = false, Reason = reason }");
+  });
+});
+
+describe("Integration: nested factory — ToolResult.text(val)", () => {
+  const registry = buildTestRegistry();
+
+  it("text(val) → Rust", () => {
+    const expr = resolveFactoryExpr(
+      { parts: [{ kind: "text", value: "{val}" }] },
+      { val: "string" },
+      toolResult,
+      registry,
+    );
+    const code = new RustExprVisitor().visitExpr(expr);
+    assert.equal(
+      code,
+      "ToolResult { parts: vec![ContentPart { kind: ContentPartKind::TextPart { value: val.into() }, ..Default::default() }], ..Default::default() }",
+    );
+  });
+
+  it("text(val) → TypeScript", () => {
+    const expr = resolveFactoryExpr(
+      { parts: [{ kind: "text", value: "{val}" }] },
+      { val: "string" },
+      toolResult,
+      registry,
+    );
+    const code = new TypeScriptExprVisitor().visitExpr(expr);
+    assert.equal(code, "new ToolResult({ parts: [new TextPart({ value: val })] })");
+  });
+
+  it("text(val) → Python", () => {
+    const expr = resolveFactoryExpr(
+      { parts: [{ kind: "text", value: "{val}" }] },
+      { val: "string" },
+      toolResult,
+      registry,
+    );
+    const code = new PythonExprVisitor().visitExpr(expr);
+    assert.equal(code, "ToolResult(parts=[TextPart(value=val)])");
+  });
+
+  it("text(val) → C#", () => {
+    const expr = resolveFactoryExpr(
+      { parts: [{ kind: "text", value: "{val}" }] },
+      { val: "string" },
+      toolResult,
+      registry,
+    );
+    const code = new CSharpExprVisitor().visitExpr(expr);
+    assert.equal(code, "new ToolResult { Parts = new List<ContentPart> { new TextPart { Value = val } } }");
+  });
+
+  it("text(val) → Go", () => {
+    const expr = resolveFactoryExpr(
+      { parts: [{ kind: "text", value: "{val}" }] },
+      { val: "string" },
+      toolResult,
+      registry,
+    );
+    const code = new GoExprVisitor(registry).visitExpr(expr);
+    assert.equal(code, 'ToolResult{ Parts: []interface{}{TextPart{ Kind: "text", Value: val }} }');
+  });
+});
+
+describe("Integration: coercion — Model from string", () => {
+  const registry = buildTestRegistry();
+
+  it("Model coercion → Rust", () => {
+    const expr = resolveCoerceExpr({ id: "{value}" }, "string", modelType, registry);
+    const code = new RustExprVisitor().visitExpr(expr);
+    assert.equal(code, 'Model { id: value.into(), ..Default::default() }');
+  });
+
+  it("Model coercion → TypeScript", () => {
+    const expr = resolveCoerceExpr({ id: "{value}" }, "string", modelType, registry);
+    const code = new TypeScriptExprVisitor().visitExpr(expr);
+    assert.equal(code, "new Model({ id: value })");
+  });
+
+  it("Model coercion → Python", () => {
+    const expr = resolveCoerceExpr({ id: "{value}" }, "string", modelType, registry);
+    const code = new PythonExprVisitor().visitExpr(expr);
+    assert.equal(code, "Model(id=value)");
+  });
+
+  it("Model coercion → C#", () => {
+    const expr = resolveCoerceExpr({ id: "{value}" }, "string", modelType, registry);
+    const code = new CSharpExprVisitor().visitExpr(expr);
+    assert.equal(code, "new Model { Id = value }");
+  });
+});
+
+describe("Integration: Message.user(text) nested factory", () => {
+  const registry = buildTestRegistry();
+
+  it("user(text) → all 5 languages", () => {
+    const expr = resolveFactoryExpr(
+      { role: "user", parts: [{ kind: "text", value: "{text}" }] },
+      { text: "string" },
+      message,
+      registry,
+    );
+
+    // Verify IR structure first
+    assert.equal(expr.kind, "construct");
+    assert.equal(expr.fields.length, 2);
+    assert.equal(expr.fields[0].propertyName, "role");
+    assert.deepStrictEqual(expr.fields[0].value, { kind: "string", value: "user" });
+    assert.equal(expr.fields[1].propertyName, "parts");
+    assert.equal(expr.fields[1].value.kind, "array");
+
+    // Verify each language
+    const expected: Record<string, string> = {
+      rust: 'Message { role: "user".to_string(), parts: vec![ContentPart { kind: ContentPartKind::TextPart { value: text.into() }, ..Default::default() }], ..Default::default() }',
+      typescript: 'new Message({ role: "user", parts: [new TextPart({ value: text })] })',
+      python: 'Message(role="user", parts=[TextPart(value=text)])',
+      csharp: 'new Message { Role = "user", Parts = new List<ContentPart> { new TextPart { Value = text } } }',
+      go: 'Message{ Role: "user", Parts: []interface{}{TextPart{ Kind: "text", Value: text }} }',
+    };
+
+    for (const [lang, expectedCode] of Object.entries(expected)) {
+      const code = getVisitor(lang, registry).visitExpr(expr);
+      assert.equal(code, expectedCode, `${lang} output mismatch`);
+    }
+  });
+});
+
+// ============================================================================
+// FieldRead tests — wire format field access per language
+// ============================================================================
+
+describe("FieldRead visitor output", () => {
+  const fieldRead: Expr = {
+    kind: "field_read",
+    objectName: "opts",
+    fieldName: "maxOutputTokens",
+    fieldType: "int32",
+    isOptional: true,
+  };
+
+  it("Rust → snake_case field access", () => {
+    const code = new RustExprVisitor().visitExpr(fieldRead);
+    assert.equal(code, "opts.max_output_tokens");
+  });
+
+  it("TypeScript → camelCase field access", () => {
+    const code = new TypeScriptExprVisitor().visitExpr(fieldRead);
+    assert.equal(code, "opts.maxOutputTokens");
+  });
+
+  it("Python → snake_case field access", () => {
+    const code = new PythonExprVisitor().visitExpr(fieldRead);
+    assert.equal(code, "opts.max_output_tokens");
+  });
+
+  it("C# → PascalCase field access", () => {
+    const code = new CSharpExprVisitor().visitExpr(fieldRead);
+    assert.equal(code, "opts.MaxOutputTokens");
+  });
+
+  it("Go → PascalCase field access", () => {
+    const code = new GoExprVisitor().visitExpr(fieldRead);
+    assert.equal(code, "opts.MaxOutputTokens");
+  });
+
+  it("simple non-camelCase field", () => {
+    const simple: Expr = {
+      kind: "field_read",
+      objectName: "model",
+      fieldName: "id",
+      fieldType: "string",
+      isOptional: false,
+    };
+    assert.equal(new RustExprVisitor().visitExpr(simple), "model.id");
+    assert.equal(new TypeScriptExprVisitor().visitExpr(simple), "model.id");
+    assert.equal(new PythonExprVisitor().visitExpr(simple), "model.id");
+    assert.equal(new CSharpExprVisitor().visitExpr(simple), "model.Id");
+    assert.equal(new GoExprVisitor().visitExpr(simple), "model.Id");
+  });
+});
+
+describe("getVisitor with registry", () => {
+  it("passes registry to visitor", () => {
+    const registry = new TypeRegistry();
+    const visitor = getVisitor("rust", registry);
+    assert.equal(visitor.registry, registry);
+  });
+
+  it("works without registry", () => {
+    const visitor = getVisitor("rust");
+    assert.equal(visitor.registry, undefined);
+  });
+});
diff --git a/schema/model/agent.tsp b/schema/model/agent/agent.tsp
similarity index 93%
rename from schema/model/agent.tsp
rename to schema/model/agent/agent.tsp
index 71d00396..a27306e5 100644
--- a/schema/model/agent.tsp
+++ b/schema/model/agent/agent.tsp
@@ -1,10 +1,14 @@
-import "agentschema-emitter";
+import "prompty-emitter";
 import "@typespec/json-schema";
-import "./core.tsp";
-import "./model.tsp";
-import "./properties.tsp";
-import "./tools.tsp";
-import "./template.tsp";
+import "../core/core.tsp";
+import "../model/model.tsp";
+import "../core/properties.tsp";
+import "../tools/tool.tsp";
+import "../tools/mcp.tsp";
+import "../tools/openapi.tsp";
+import "../tools/prompty.tsp";
+import "../tools/dispatch.tsp";
+import "../template/template.tsp";
 
 using TypeSpec.JsonSchema;
 
diff --git a/schema/model/agent/guardrails.tsp b/schema/model/agent/guardrails.tsp
new file mode 100644
index 00000000..650f34a0
--- /dev/null
+++ b/schema/model/agent/guardrails.tsp
@@ -0,0 +1,29 @@
+import "prompty-emitter";
+
+namespace Prompty;
+
+/**
+ * The phase of the pipeline at which a guardrail is evaluated.
+ */
+alias GuardrailPhase = "input" | "output" | "tool";
+
+/**
+ * The result of a guardrail evaluation. Guardrails are safety checks that
+ * run at specific phases of the agent loop and can allow, deny, or rewrite
+ * content.
+ */
+@factory("allow", #{ allowed: true })
+@factory("deny", #{ allowed: false }, #{ reason: "string" })
+@factory("rewrite", #{ allowed: true }, #{ rewrite: "unknown" })
+model GuardrailResult {
+  @doc("Whether the content passed the guardrail check")
+  @sample(#{ allowed: true })
+  allowed: boolean;
+
+  @doc("Explanation of why the content was allowed or denied")
+  @sample(#{ reason: "Content is safe" })
+  reason?: string;
+
+  @doc("Optional rewritten content to replace the original")
+  rewrite?: unknown;
+}
diff --git a/schema/model/connection.tsp b/schema/model/connection/connection.tsp
similarity index 63%
rename from schema/model/connection.tsp
rename to schema/model/connection/connection.tsp
index e99a0056..9358721e 100644
--- a/schema/model/connection.tsp
+++ b/schema/model/connection/connection.tsp
@@ -1,5 +1,5 @@
-import "agentschema-emitter";
-import "./core.tsp";
+import "prompty-emitter";
+import "../core/core.tsp";
 
 namespace Prompty;
 
@@ -101,61 +101,3 @@ model AnonymousConnection extends Connection {
   @sample(#{ endpoint: "https://{your-custom-endpoint}.openai.azure.com/" })
   endpoint: string;
 }
-
-/**
- * Connection configuration for Microsoft Foundry projects.
- * Provides project-scoped access to models, tools, and services
- * via Entra ID (DefaultAzureCredential) authentication.
- */
-model FoundryConnection extends Connection {
-  @doc("The connection kind for Foundry project access")
-  @sample(#{ kind: "foundry" })
-  kind: "foundry";
-
-  @doc("The Foundry project endpoint URL")
-  @sample(#{
-    endpoint: "https://myresource.services.ai.azure.com/api/projects/myproject",
-  })
-  endpoint: string;
-
-  @doc("The named connection within the Foundry project")
-  @sample(#{ name: "my-openai-connection" })
-  name?: string;
-
-  @doc("The connection type within the Foundry project (e.g., 'model', 'index', 'storage')")
-  @sample(#{ connectionType: "model" })
-  connectionType?: string;
-}
-
-/**
- * Connection configuration using OAuth 2.0 client credentials.
- * Useful for tools and services that require OAuth authentication,
- * such as MCP servers, OpenAPI endpoints, or other REST APIs.
- */
-model OAuthConnection extends Connection {
-  @doc("The connection kind for OAuth authentication")
-  @sample(#{ kind: "oauth" })
-  kind: "oauth";
-
-  @doc("The endpoint URL for the service")
-  @sample(#{ endpoint: "https://api.example.com" })
-  endpoint: string;
-
-  @doc("The OAuth client ID")
-  @sample(#{ clientId: "your-client-id" })
-  clientId: string;
-
-  @doc("The OAuth client secret")
-  @sample(#{ clientSecret: "your-client-secret" })
-  clientSecret: string;
-
-  @doc("The OAuth token endpoint URL")
-  @sample(#{
-    tokenUrl: "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token",
-  })
-  tokenUrl: string;
-
-  @doc("OAuth scopes to request")
-  @sample(#{ scopes: #["https://cognitiveservices.azure.com/.default"] })
-  scopes?: string[];
-}
diff --git a/schema/model/connection/foundry.tsp b/schema/model/connection/foundry.tsp
new file mode 100644
index 00000000..43b8fcba
--- /dev/null
+++ b/schema/model/connection/foundry.tsp
@@ -0,0 +1,29 @@
+import "prompty-emitter";
+import "./connection.tsp";
+
+namespace Prompty;
+
+/**
+ * Connection configuration for Microsoft Foundry projects.
+ * Provides project-scoped access to models, tools, and services
+ * via Entra ID (DefaultAzureCredential) authentication.
+ */
+model FoundryConnection extends Connection {
+  @doc("The connection kind for Foundry project access")
+  @sample(#{ kind: "foundry" })
+  kind: "foundry";
+
+  @doc("The Foundry project endpoint URL")
+  @sample(#{
+    endpoint: "https://myresource.services.ai.azure.com/api/projects/myproject",
+  })
+  endpoint: string;
+
+  @doc("The named connection within the Foundry project")
+  @sample(#{ name: "my-openai-connection" })
+  name?: string;
+
+  @doc("The connection type within the Foundry project (e.g., 'model', 'index', 'storage')")
+  @sample(#{ connectionType: "model" })
+  connectionType?: string;
+}
diff --git a/schema/model/connection/oauth.tsp b/schema/model/connection/oauth.tsp
new file mode 100644
index 00000000..366381f4
--- /dev/null
+++ b/schema/model/connection/oauth.tsp
@@ -0,0 +1,37 @@
+import "prompty-emitter";
+import "./connection.tsp";
+
+namespace Prompty;
+
+/**
+ * Connection configuration using OAuth 2.0 client credentials.
+ * Useful for tools and services that require OAuth authentication,
+ * such as MCP servers, OpenAPI endpoints, or other REST APIs.
+ */
+model OAuthConnection extends Connection {
+  @doc("The connection kind for OAuth authentication")
+  @sample(#{ kind: "oauth" })
+  kind: "oauth";
+
+  @doc("The endpoint URL for the service")
+  @sample(#{ endpoint: "https://api.example.com" })
+  endpoint: string;
+
+  @doc("The OAuth client ID")
+  @sample(#{ clientId: "your-client-id" })
+  clientId: string;
+
+  @doc("The OAuth client secret")
+  @sample(#{ clientSecret: "your-client-secret" })
+  clientSecret: string;
+
+  @doc("The OAuth token endpoint URL")
+  @sample(#{
+    tokenUrl: "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token",
+  })
+  tokenUrl: string;
+
+  @doc("OAuth scopes to request")
+  @sample(#{ scopes: #["https://cognitiveservices.azure.com/.default"] })
+  scopes?: string[];
+}
diff --git a/schema/model/conversation/content.tsp b/schema/model/conversation/content.tsp
new file mode 100644
index 00000000..c339efcb
--- /dev/null
+++ b/schema/model/conversation/content.tsp
@@ -0,0 +1,83 @@
+import "prompty-emitter";
+
+namespace Prompty;
+
+/**
+ * The kind discriminator for content parts.
+ */
+alias ContentPartType = "text" | "image" | "file" | "audio";
+
+/**
+ * A part of a message's content. Content parts are discriminated on the `kind`
+ * field and represent the different modalities that can appear in a message.
+ */
+@abstract
+@discriminator("kind")
+model ContentPart {
+  @doc("The kind of content part")
+  kind: ContentPartType;
+}
+
+/**
+ * A text content part.
+ */
+model TextPart extends ContentPart {
+  @doc("The kind identifier for text content")
+  kind: "text";
+
+  @doc("The text content")
+  @sample(#{ value: "Hello, world!" })
+  value: string;
+}
+
+/**
+ * An image content part. The source may be a URL or base64-encoded data.
+ */
+model ImagePart extends ContentPart {
+  @doc("The kind identifier for image content")
+  kind: "image";
+
+  @doc("URL or base64-encoded image data")
+  @sample(#{ source: "https://example.com/image.png" })
+  source: string;
+
+  @doc("Detail level hint for the model (e.g., 'auto', 'low', 'high')")
+  @sample(#{ detail: "auto" })
+  detail?: string;
+
+  @doc("MIME type of the image (e.g., 'image/png')")
+  @sample(#{ mediaType: "image/png" })
+  mediaType?: string;
+}
+
+/**
+ * A file content part. The source may be a URL or base64-encoded data.
+ */
+model FilePart extends ContentPart {
+  @doc("The kind identifier for file content")
+  kind: "file";
+
+  @doc("URL or base64-encoded file data")
+  @sample(#{ source: "https://example.com/document.pdf" })
+  source: string;
+
+  @doc("MIME type of the file (e.g., 'application/pdf')")
+  @sample(#{ mediaType: "application/pdf" })
+  mediaType?: string;
+}
+
+/**
+ * An audio content part. The source may be a URL or base64-encoded data.
+ */
+model AudioPart extends ContentPart {
+  @doc("The kind identifier for audio content")
+  kind: "audio";
+
+  @doc("URL or base64-encoded audio data")
+  @sample(#{ source: "https://example.com/audio.wav" })
+  source: string;
+
+  @doc("MIME type of the audio (e.g., 'audio/wav')")
+  @sample(#{ mediaType: "audio/wav" })
+  mediaType?: string;
+}
diff --git a/schema/model/conversation/message.tsp b/schema/model/conversation/message.tsp
new file mode 100644
index 00000000..99cca2af
--- /dev/null
+++ b/schema/model/conversation/message.tsp
@@ -0,0 +1,48 @@
+import "prompty-emitter";
+import "./content.tsp";
+
+namespace Prompty;
+
+/**
+ * The role of a message in a conversation.
+ */
+alias Role = "system" | "user" | "assistant" | "developer" | "tool";
+
+/**
+ * A message in a conversation. Messages have a role and a list of content parts
+ * representing the different modalities of the message content.
+ */
+@factory(
+  "user",
+  #{ role: "user", parts: #[#{ kind: "text", value: "{text}" }] },
+  #{ text: "string" }
+)
+@factory(
+  "system",
+  #{ role: "system", parts: #[#{ kind: "text", value: "{text}" }] },
+  #{ text: "string" }
+)
+@factory(
+  "assistant",
+  #{ role: "assistant", parts: #[#{ kind: "text", value: "{text}" }] },
+  #{ text: "string" }
+)
+@method("text", "string", "Concatenate all TextPart values joined by newline")
+@method(
+  "toTextContent",
+  "unknown",
+  "Return plain string if all parts are text, else a list of content part dicts for wire serialization"
+)
+model Message {
+  @doc("The role of the message sender")
+  @sample(#{ role: "user" })
+  role: Role = "user";
+
+  @doc("The content parts of the message")
+  @sample(#{ parts: #[#{ kind: "text", value: "Hello!" }] })
+  parts: ContentPart[];
+
+  @doc("Optional metadata associated with the message")
+  @sample(#{ metadata: #{ source: "user-input" } })
+  metadata: Record<unknown> = #{};
+}
diff --git a/schema/model/conversation/thread.tsp b/schema/model/conversation/thread.tsp
new file mode 100644
index 00000000..53b8bc67
--- /dev/null
+++ b/schema/model/conversation/thread.tsp
@@ -0,0 +1,20 @@
+import "prompty-emitter";
+
+namespace Prompty;
+
+/**
+ * Positional marker for conversation history insertion during template rendering.
+ *
+ * During `prepare()`, nonce strings in rendered text are replaced with
+ * ThreadMarker objects. The pipeline then replaces them with actual
+ * conversation messages from the inputs.
+ */
+model ThreadMarker {
+  @doc("The input property name (e.g. 'conversation')")
+  @sample(#{ name: "thread" })
+  name: string = "thread";
+
+  @doc("The rich kind ('thread', 'image', 'file', 'audio')")
+  @sample(#{ kind: "thread" })
+  kind: string = "thread";
+}
diff --git a/schema/model/conversation/tool-invocation.tsp b/schema/model/conversation/tool-invocation.tsp
new file mode 100644
index 00000000..fb586ef0
--- /dev/null
+++ b/schema/model/conversation/tool-invocation.tsp
@@ -0,0 +1,41 @@
+import "prompty-emitter";
+import "./content.tsp";
+
+namespace Prompty;
+
+/**
+ * A tool call requested by the LLM. Contains the function name and serialized
+ * arguments that should be dispatched to the appropriate tool handler.
+ */
+model ToolCall {
+  @doc("The unique identifier of the tool call")
+  @sample(#{ id: "call_abc123" })
+  id: string;
+
+  @doc("The name of the tool to call")
+  @sample(#{ name: "get_weather" })
+  name: string;
+
+  @doc("The serialized JSON arguments for the tool call")
+  @sample(#{ arguments: "{\"city\": \"Paris\"}" })
+  arguments: string;
+}
+
+/**
+ * The result of a tool execution. Contains a list of content parts, enabling
+ * rich tool results (text, images, files, audio) rather than just strings.
+ *
+ * Implementations MUST support conversion from a plain string to a ToolResult
+ * containing a single TextPart for backward compatibility.
+ */
+@factory(
+  "text",
+  #{ parts: #[#{ kind: "text", value: "{value}" }] },
+  #{ value: "string" }
+)
+@method("text", "string", "Concatenate all TextPart values joined by newline")
+model ToolResult {
+  @doc("The content parts of the tool result")
+  @sample(#{ parts: #[#{ kind: "text", value: "72°F and sunny" }] })
+  parts: ContentPart[];
+}
diff --git a/schema/model/core.tsp b/schema/model/core/core.tsp
similarity index 95%
rename from schema/model/core.tsp
rename to schema/model/core/core.tsp
index 2626b7ce..e52bf1ec 100644
--- a/schema/model/core.tsp
+++ b/schema/model/core/core.tsp
@@ -1,4 +1,4 @@
-import "agentschema-emitter";
+import "prompty-emitter";
 
 namespace Prompty;
 
diff --git a/schema/model/properties.tsp b/schema/model/core/properties.tsp
similarity index 97%
rename from schema/model/properties.tsp
rename to schema/model/core/properties.tsp
index d733061d..f15f084b 100644
--- a/schema/model/properties.tsp
+++ b/schema/model/core/properties.tsp
@@ -1,4 +1,4 @@
-import "agentschema-emitter";
+import "prompty-emitter";
 import "./core.tsp";
 
 namespace Prompty;
@@ -12,26 +12,26 @@ namespace Prompty;
  *   and processed to generate prompts for AI models.
  */
 @discriminator("kind")
-@shorthand(
+@coerce(
   string,
   #{ kind: "string", example: "{value}" },
   "input",
   "Simple construction with just a kind of string"
 )
-@shorthand(
+@coerce(
   integer,
   #{ kind: "integer", example: "{value}" },
   "input",
   "Simple construction with just a kind of integer",
   4
 )
-@shorthand(
+@coerce(
   float32,
   #{ kind: "float", example: "{value}" },
   "input",
   "Simple construction with just a kind of float"
 )
-@shorthand(
+@coerce(
   boolean,
   #{ kind: "boolean", example: "{value}" },
   "input",
@@ -96,7 +96,6 @@ model ObjectProperty extends Property {
   properties: Properties = #[];
 }
 
-
 alias Properties = Record<Property> | Named<
   Property,
   "Name of the property",
diff --git a/schema/model/events/payloads.tsp b/schema/model/events/payloads.tsp
new file mode 100644
index 00000000..d044524f
--- /dev/null
+++ b/schema/model/events/payloads.tsp
@@ -0,0 +1,130 @@
+import "prompty-emitter";
+import "../conversation/message.tsp";
+import "../conversation/tool-invocation.tsp";
+
+namespace Prompty;
+
+/**
+ * The type of event emitted during agent loop execution. Events enable
+ * real-time UIs, logging, and coordination without coupling the loop
+ * to any particular output mechanism.
+ */
+alias AgentEventType =
+  | "token"
+  | "thinking"
+  | "tool_call_start"
+  | "tool_result"
+  | "status"
+  | "messages_updated"
+  | "done"
+  | "error"
+  | "cancelled"
+  | "compaction_start"
+  | "compaction_complete"
+  | "compaction_failed";
+
+/**
+ * Payload for "token" events — a single text token streamed from the LLM.
+ */
+model TokenEventPayload {
+  @doc("The streamed token text")
+  @sample(#{ token: "Hello" })
+  token: string;
+}
+
+/**
+ * Payload for "thinking" events — reasoning/chain-of-thought tokens.
+ */
+model ThinkingEventPayload {
+  @doc("The thinking/reasoning token text")
+  @sample(#{ token: "Let me consider..." })
+  token: string;
+}
+
+/**
+ * Payload for "tool_call_start" events — the LLM has requested a tool call.
+ */
+model ToolCallStartPayload {
+  @doc("The name of the tool being called")
+  @sample(#{ name: "get_weather" })
+  name: string;
+
+  @doc("The serialized JSON arguments for the tool call")
+  @sample(#{ arguments: "{\"city\": \"Paris\"}" })
+  arguments: string;
+}
+
+/**
+ * Payload for "tool_result" events — a tool has returned its result.
+ */
+model ToolResultPayload {
+  @doc("The name of the tool that produced the result")
+  @sample(#{ name: "get_weather" })
+  name: string;
+
+  @doc("The tool's result")
+  @sample(#{
+    result: #{ parts: #[#{ kind: "text", value: "72°F and sunny" }] },
+  })
+  result: ToolResult;
+}
+
+/**
+ * Payload for "status" events — informational messages about loop progress.
+ */
+model StatusEventPayload {
+  @doc("Human-readable status message")
+  @sample(#{ message: "Starting iteration 3" })
+  message: string;
+}
+
+/**
+ * Payload for "messages_updated" events — the conversation state has changed.
+ */
+model MessagesUpdatedPayload {
+  @doc("The current full message list after the update")
+  messages: Message[];
+}
+
+/**
+ * Payload for "done" events — the agent loop completed successfully.
+ */
+model DoneEventPayload {
+  @doc("The final text response from the LLM")
+  @sample(#{ response: "The weather in Paris is 72°F and sunny." })
+  response: string;
+
+  @doc("The final conversation state including all messages")
+  messages: Message[];
+}
+
+/**
+ * Payload for "error" events — an error occurred during the loop.
+ */
+model ErrorEventPayload {
+  @doc("Human-readable error description")
+  @sample(#{ message: "Rate limit exceeded" })
+  message: string;
+}
+
+/**
+ * Payload for "compaction_complete" events — context compaction finished.
+ */
+model CompactionCompletePayload {
+  @doc("Number of messages removed during compaction")
+  @sample(#{ removed: 5 })
+  removed: int32;
+
+  @doc("Number of messages remaining after compaction")
+  @sample(#{ remaining: 3 })
+  remaining: int32;
+}
+
+/**
+ * Payload for "compaction_failed" events — compaction could not be completed.
+ */
+model CompactionFailedPayload {
+  @doc("Explanation of why compaction failed")
+  @sample(#{ message: "Summarization prompt exceeded context window" })
+  message: string;
+}
diff --git a/schema/model/events/stream-chunks.tsp b/schema/model/events/stream-chunks.tsp
new file mode 100644
index 00000000..df018094
--- /dev/null
+++ b/schema/model/events/stream-chunks.tsp
@@ -0,0 +1,74 @@
+import "prompty-emitter";
+import "../conversation/tool-invocation.tsp";
+
+namespace Prompty;
+
+/**
+ * The kind discriminator for stream chunks.
+ */
+alias StreamChunkType = "text" | "thinking" | "tool" | "error";
+
+/**
+ * A chunk of data from a streaming LLM response. Stream chunks are
+ * discriminated on the `kind` field.
+ */
+@abstract
+@discriminator("kind")
+model StreamChunk {
+  @doc("The kind of stream chunk")
+  kind: StreamChunkType;
+}
+
+/**
+ * A text content chunk from the LLM response stream.
+ */
+model TextChunk extends StreamChunk {
+  @doc("The kind identifier for text chunks")
+  kind: "text";
+
+  @doc("The text content of the chunk")
+  @sample(#{ value: "Hello" })
+  value: string;
+}
+
+/**
+ * A thinking/reasoning content chunk from the LLM response stream.
+ */
+model ThinkingChunk extends StreamChunk {
+  @doc("The kind identifier for thinking chunks")
+  kind: "thinking";
+
+  @doc("The thinking content of the chunk")
+  @sample(#{ value: "Let me consider..." })
+  value: string;
+}
+
+/**
+ * A tool call chunk from the LLM response stream.
+ */
+model ToolChunk extends StreamChunk {
+  @doc("The kind identifier for tool chunks")
+  kind: "tool";
+
+  @doc("The tool call data")
+  @sample(#{
+    toolCall: #{
+      id: "call_abc123",
+      name: "get_weather",
+      arguments: "{\"city\": \"Paris\"}",
+    },
+  })
+  toolCall: ToolCall;
+}
+
+/**
+ * An error chunk from the LLM response stream.
+ */
+model ErrorChunk extends StreamChunk {
+  @doc("The kind identifier for error chunks")
+  kind: "error";
+
+  @doc("The error message")
+  @sample(#{ message: "Rate limit exceeded" })
+  message: string;
+}
diff --git a/schema/model/main.tsp b/schema/model/main.tsp
index 4f651254..5bde9d80 100644
--- a/schema/model/main.tsp
+++ b/schema/model/main.tsp
@@ -1,2 +1,42 @@
 // Prompty schema entry point
-import "./agent.tsp";
+
+// Agent
+import "./agent/agent.tsp";
+import "./agent/guardrails.tsp";
+
+// Conversation state
+import "./conversation/message.tsp";
+import "./conversation/content.tsp";
+import "./conversation/tool-invocation.tsp";
+import "./conversation/thread.tsp";
+
+// Model + usage + discovery
+import "./model/usage.tsp";
+import "./model/discovery.tsp";
+
+// Pipeline (turn options + protocol contracts)
+import "./pipeline/turn.tsp";
+import "./pipeline/renderer.tsp";
+import "./pipeline/parser.tsp";
+import "./pipeline/executor.tsp";
+import "./pipeline/processor.tsp";
+
+// Events
+import "./events/payloads.tsp";
+import "./events/stream-chunks.tsp";
+
+// Tools (declarations + dispatch)
+import "./tools/tool.tsp";
+import "./tools/mcp.tsp";
+import "./tools/openapi.tsp";
+import "./tools/prompty.tsp";
+import "./tools/dispatch.tsp";
+
+// Connections
+import "./connection/connection.tsp";
+import "./connection/oauth.tsp";
+import "./connection/foundry.tsp";
+
+// Wire format mappings (augment existing models with provider field names)
+import "./wire/openai.tsp";
+import "./wire/anthropic.tsp";
diff --git a/schema/model/model/discovery.tsp b/schema/model/model/discovery.tsp
new file mode 100644
index 00000000..e3533401
--- /dev/null
+++ b/schema/model/model/discovery.tsp
@@ -0,0 +1,41 @@
+import "prompty-emitter";
+
+namespace Prompty;
+
+/**
+ * Information about a model available from a provider. Used by provider-level
+ * model discovery to report which models are available and their capabilities.
+ *
+ * Not all providers return all fields — implementations SHOULD populate as
+ * many fields as the provider's API supports and MAY enrich sparse results
+ * from a built-in lookup table of known models.
+ */
+model ModelInfo {
+  @doc("The model identifier (e.g., 'gpt-4o', 'claude-3-opus')")
+  @sample(#{ id: "gpt-4o" })
+  id: string;
+
+  @doc("Human-readable display name")
+  @sample(#{ displayName: "GPT-4o" })
+  displayName?: string;
+
+  @doc("The organization or entity that owns the model")
+  @sample(#{ ownedBy: "openai" })
+  ownedBy?: string;
+
+  @doc("Maximum context window size in tokens")
+  @sample(#{ contextWindow: 128000 })
+  contextWindow?: int32;
+
+  @doc("Input modalities the model accepts (e.g., 'text', 'image', 'audio')")
+  @sample(#{ inputModalities: #["text", "image"] })
+  inputModalities?: string[];
+
+  @doc("Output modalities the model can produce (e.g., 'text', 'audio')")
+  @sample(#{ outputModalities: #["text"] })
+  outputModalities?: string[];
+
+  @doc("Additional provider-specific properties")
+  @sample(#{ additionalProperties: #{ supportsStreaming: true } })
+  additionalProperties?: Record<unknown>;
+}
diff --git a/schema/model/model.tsp b/schema/model/model/model.tsp
similarity index 93%
rename from schema/model/model.tsp
rename to schema/model/model/model.tsp
index 3f79bdb5..59add56d 100644
--- a/schema/model/model.tsp
+++ b/schema/model/model/model.tsp
@@ -1,5 +1,5 @@
-import "./core.tsp";
-import "./connection.tsp";
+import "../core/core.tsp";
+import "../connection/connection.tsp";
 
 namespace Prompty;
 
@@ -59,7 +59,7 @@ model ModelOptions {
  * This model includes properties for specifying the model's provider, connection details, and various options.
  * It allows for flexible configuration of AI models to suit different use cases and requirements.
  */
-@shorthand(
+@coerce(
   string,
   #{ id: "{value}" },
   "model",
@@ -89,6 +89,8 @@ model Model {
   connection?: Connection;
 
   @doc("Additional options for the model")
-  @sample(#{ options: #{ type: "chat", temperature: 0.7, maxOutputTokens: 1000 } })
+  @sample(#{
+    options: #{ type: "chat", temperature: 0.7, maxOutputTokens: 1000 },
+  })
   options?: ModelOptions;
 }
diff --git a/schema/model/model/usage.tsp b/schema/model/model/usage.tsp
new file mode 100644
index 00000000..80b73a8f
--- /dev/null
+++ b/schema/model/model/usage.tsp
@@ -0,0 +1,22 @@
+import "prompty-emitter";
+
+namespace Prompty;
+
+/**
+ * Tracks token consumption for a single LLM call. Provider-specific field
+ * names (e.g., OpenAI's `prompt_tokens` vs Anthropic's `input_tokens`)
+ * are mapped via `knownAs` augments in the wire directory.
+ */
+model TokenUsage {
+  @doc("Number of tokens in the prompt/input sent to the model")
+  @sample(#{ promptTokens: 150 })
+  promptTokens?: int32;
+
+  @doc("Number of tokens generated in the model's completion/output")
+  @sample(#{ completionTokens: 42 })
+  completionTokens?: int32;
+
+  @doc("Total tokens consumed (prompt + completion). May be provided by the API or computed.")
+  @sample(#{ totalTokens: 192 })
+  totalTokens?: int32;
+}
diff --git a/schema/model/pipeline/executor.tsp b/schema/model/pipeline/executor.tsp
new file mode 100644
index 00000000..555fb865
--- /dev/null
+++ b/schema/model/pipeline/executor.tsp
@@ -0,0 +1,37 @@
+import "prompty-emitter";
+import "../agent/agent.tsp";
+import "../conversation/message.tsp";
+import "../conversation/tool-invocation.tsp";
+
+namespace Prompty;
+
+@@protocol(Executor);
+@@method(Executor,
+  "execute",
+  "unknown",
+  "Call an LLM provider with messages and return the raw response",
+  #{ agent: "Prompty", messages: "Message[]" }
+);
+@@method(Executor,
+  "executeStream",
+  "unknown",
+  "Call an LLM provider and return a streaming response. Returns a language-specific async iterable/stream of raw chunks. Not all providers support streaming; the default implementation should signal lack of support.",
+  #{ agent: "Prompty", messages: "Message[]" },
+  true
+);
+@@method(Executor,
+  "formatToolMessages",
+  "Message[]",
+  "Format tool call results into messages for the next iteration",
+  #{
+    rawResponse: "unknown",
+    toolCalls: "ToolCall[]",
+    toolResults: "string[]",
+    textContent: "string?",
+  },
+  false,
+  true
+);
+
+/** Calls an LLM provider with messages and returns the raw provider response. */
+model Executor {}
diff --git a/schema/model/pipeline/parser.tsp b/schema/model/pipeline/parser.tsp
new file mode 100644
index 00000000..566d03ce
--- /dev/null
+++ b/schema/model/pipeline/parser.tsp
@@ -0,0 +1,24 @@
+import "prompty-emitter";
+import "../agent/agent.tsp";
+import "../conversation/message.tsp";
+
+namespace Prompty;
+
+@@protocol(Parser);
+@@method(Parser,
+  "preRender",
+  "unknown?",
+  "Pre-process a template before rendering, returning modified template and context",
+  #{ template: "string" },
+  true,
+  true
+);
+@@method(Parser,
+  "parse",
+  "Message[]",
+  "Parse rendered text into a structured message array",
+  #{ agent: "Prompty", rendered: "string", context: "Record<unknown>?" }
+);
+
+/** Parses rendered prompt text into an array of structured messages with role markers. */
+model Parser {}
diff --git a/schema/model/pipeline/processor.tsp b/schema/model/pipeline/processor.tsp
new file mode 100644
index 00000000..5ddc4d07
--- /dev/null
+++ b/schema/model/pipeline/processor.tsp
@@ -0,0 +1,22 @@
+import "prompty-emitter";
+import "../agent/agent.tsp";
+
+namespace Prompty;
+
+@@protocol(Processor);
+@@method(Processor,
+  "process",
+  "unknown",
+  "Extract a clean result from a raw LLM response",
+  #{ agent: "Prompty", response: "unknown" }
+);
+@@method(Processor,
+  "processStream",
+  "unknown",
+  "Process a streaming response into a stream of StreamChunk items. Takes raw chunks from the executor and yields processed text, thinking, tool, or error chunks. Not all providers support streaming; the default implementation should signal lack of support.",
+  #{ stream: "unknown" },
+  true
+);
+
+/** Extracts a clean, typed result from a raw LLM provider response. */
+model Processor {}
diff --git a/schema/model/pipeline/renderer.tsp b/schema/model/pipeline/renderer.tsp
new file mode 100644
index 00000000..1b67bc86
--- /dev/null
+++ b/schema/model/pipeline/renderer.tsp
@@ -0,0 +1,15 @@
+import "prompty-emitter";
+import "../agent/agent.tsp";
+
+namespace Prompty;
+
+@@protocol(Renderer);
+@@method(Renderer,
+  "render",
+  "string",
+  "Render the template string with input values",
+  #{ agent: "Prompty", template: "string", inputs: "Record<unknown>" }
+);
+
+/** Renders a template string with input values to produce the final prompt text. */
+model Renderer {}
diff --git a/schema/model/pipeline/turn.tsp b/schema/model/pipeline/turn.tsp
new file mode 100644
index 00000000..3eecbcf4
--- /dev/null
+++ b/schema/model/pipeline/turn.tsp
@@ -0,0 +1,60 @@
+import "prompty-emitter";
+
+namespace Prompty;
+
+/**
+ * Configuration for the agent loop's turn() function. Controls iteration
+ * limits, retry policy, context management, and execution behavior.
+ *
+ * Runtimes accept these as either a TurnOptions object or individual
+ * keyword/named parameters — the TypeSpec model defines the canonical
+ * field set.
+ */
+model TurnOptions {
+  @doc("Maximum number of tool-call iterations before the loop terminates")
+  @sample(#{ maxIterations: 10 })
+  maxIterations?: int32 = 10;
+
+  @doc("Maximum number of LLM call retries on transient failure within a single iteration")
+  @sample(#{ maxLlmRetries: 3 })
+  maxLlmRetries?: int32 = 3;
+
+  @doc("Character budget for the context window. When set, the loop trims older messages to stay within budget before each LLM call. System messages are never dropped.")
+  @sample(#{ contextBudget: 100000 })
+  contextBudget?: int32;
+
+  @doc("Whether to execute multiple tool calls concurrently when the LLM returns several in one response")
+  @sample(#{ parallelToolCalls: true })
+  parallelToolCalls?: boolean = false;
+
+  @doc("When true, return the raw LLM response without processor post-processing")
+  @sample(#{ raw: false })
+  raw?: boolean = false;
+
+  @doc("Turn number for trace labeling. Useful when the caller maintains an outer conversation loop.")
+  @sample(#{ turn: 1 })
+  turn?: int32;
+
+  @doc("Context compaction configuration. Controls how messages are summarized when the context window exceeds the budget.")
+  @sample(#{ compaction: #{ strategy: "summarize" } })
+  compaction?: CompactionConfig;
+}
+
+/**
+ * Configuration for context window compaction. When the message history
+ * exceeds the context budget, the compaction strategy is applied to
+ * reduce the message list while preserving essential information.
+ */
+model CompactionConfig {
+  @doc("The compaction strategy identifier. Built-in strategies include 'summarize'. Can also be a path to a .prompty file used as the summarization prompt.")
+  @sample(#{ strategy: "summarize" })
+  strategy?: string;
+
+  @doc("Character budget for the compacted context. Overrides TurnOptions.contextBudget when set.")
+  @sample(#{ budget: 50000 })
+  budget?: int32;
+
+  @doc("Additional strategy-specific options")
+  @sample(#{ options: #{ preserveSystemMessages: true } })
+  options?: Record<unknown> = #{};
+}
diff --git a/schema/model/template.tsp b/schema/model/template/template.tsp
similarity index 96%
rename from schema/model/template.tsp
rename to schema/model/template/template.tsp
index 7d98558e..0d6cf7c8 100644
--- a/schema/model/template.tsp
+++ b/schema/model/template/template.tsp
@@ -1,5 +1,5 @@
-import "agentschema-emitter";
-import "./core.tsp";
+import "prompty-emitter";
+import "../core/core.tsp";
 
 namespace Prompty;
 
@@ -28,7 +28,7 @@ model Template {
  * Template format definition
  */
 @discriminator("kind")
-@shorthand(
+@coerce(
   string,
   #{ kind: "{value}" },
   "format",
@@ -52,7 +52,7 @@ model FormatConfig {
  * Template parser definition
  */
 @discriminator("kind")
-@shorthand(
+@coerce(
   string,
   #{ kind: "{value}" },
   "parser",
diff --git a/schema/model/tools/dispatch.tsp b/schema/model/tools/dispatch.tsp
new file mode 100644
index 00000000..e9b6a604
--- /dev/null
+++ b/schema/model/tools/dispatch.tsp
@@ -0,0 +1,40 @@
+import "prompty-emitter";
+import "../conversation/message.tsp";
+import "../conversation/tool-invocation.tsp";
+
+namespace Prompty;
+
+/**
+ * Context passed to tool handlers during agent loop execution. Provides
+ * access to the agent configuration, current conversation state, and
+ * arbitrary metadata for tool implementations that need broader context.
+ */
+model ToolContext {
+  @doc("The current conversation messages at the point of tool invocation")
+  messages: Message[];
+
+  @doc("Optional metadata for tool-specific context (e.g., user session info)")
+  @sample(#{ metadata: #{ userId: "user-123" } })
+  metadata?: Record<unknown>;
+}
+
+/**
+ * The result of dispatching a single tool call. Pairs the tool call
+ * identifier with the tool's name and result for correlation in the
+ * agent loop's message assembly.
+ */
+model ToolDispatchResult {
+  @doc("The tool call ID from the LLM response, used to correlate results")
+  @sample(#{ toolCallId: "call_abc123" })
+  toolCallId: string;
+
+  @doc("The name of the tool that was called")
+  @sample(#{ name: "get_weather" })
+  name: string;
+
+  @doc("The result produced by the tool handler")
+  @sample(#{
+    result: #{ parts: #[#{ kind: "text", value: "72°F and sunny" }] },
+  })
+  result: ToolResult;
+}
diff --git a/schema/model/tools/main.tsp b/schema/model/tools/main.tsp
deleted file mode 100644
index ed50b1c9..00000000
--- a/schema/model/tools/main.tsp
+++ /dev/null
@@ -1,3 +0,0 @@
-import "./mcp.tsp";
-import "./openapi.tsp";
-import "./prompty.tsp";
diff --git a/schema/model/tools/mcp.tsp b/schema/model/tools/mcp.tsp
index c67c8176..419d08d6 100644
--- a/schema/model/tools/mcp.tsp
+++ b/schema/model/tools/mcp.tsp
@@ -1,6 +1,6 @@
-import "../core.tsp";
-import "../tools.tsp";
-import "../connection.tsp";
+import "../core/core.tsp";
+import "./tool.tsp";
+import "../connection/connection.tsp";
 
 namespace Prompty;
 
@@ -40,7 +40,7 @@ alias mcpApprovalModeKind = "always" | "never" | "specify";
  * When kind is "specify", use alwaysRequireApprovalTools and neverRequireApprovalTools
  * to control per-tool approval. For "always" and "never", those fields are ignored.
  */
-@shorthand(string, #{ kind: "{value}" }, "kind", "Mcp Approval Mode", "never")
+@coerce(string, #{ kind: "{value}" }, "kind", "Mcp Approval Mode", "never")
 model McpApprovalMode {
   @doc("The approval mode: 'always', 'never', or 'specify'")
   @sample(#{ kind: "never" })
diff --git a/schema/model/tools/openapi.tsp b/schema/model/tools/openapi.tsp
index e6065cd0..093b63c8 100644
--- a/schema/model/tools/openapi.tsp
+++ b/schema/model/tools/openapi.tsp
@@ -1,6 +1,6 @@
-import "../core.tsp";
-import "../tools.tsp";
-import "../connection.tsp";
+import "../core/core.tsp";
+import "./tool.tsp";
+import "../connection/connection.tsp";
 
 namespace Prompty;
 
diff --git a/schema/model/tools/prompty.tsp b/schema/model/tools/prompty.tsp
index 3480ccfe..a02031ed 100644
--- a/schema/model/tools/prompty.tsp
+++ b/schema/model/tools/prompty.tsp
@@ -1,5 +1,5 @@
-import "../core.tsp";
-import "../tools.tsp";
+import "../core/core.tsp";
+import "./tool.tsp";
 
 namespace Prompty;
 
diff --git a/schema/model/tools.tsp b/schema/model/tools/tool.tsp
similarity index 94%
rename from schema/model/tools.tsp
rename to schema/model/tools/tool.tsp
index 7588654e..018d9f12 100644
--- a/schema/model/tools.tsp
+++ b/schema/model/tools/tool.tsp
@@ -1,14 +1,14 @@
-import "agentschema-emitter";
-import "./core.tsp";
-import "./tools";
-import "./properties.tsp";
+import "prompty-emitter";
+import "../core/core.tsp";
+import "../core/properties.tsp";
+import "../connection/connection.tsp";
 
 namespace Prompty;
 
 /**
  * Represents a binding between an input property and a tool parameter.
  */
-@shorthand(string, #{ input: "{value}" })
+@coerce(string, #{ input: "{value}" })
 model Binding {
   @doc("The input property that will be bound to the tool parameter argument")
   @sample(#{ input: "input-variable" })
diff --git a/schema/model/wire/anthropic.tsp b/schema/model/wire/anthropic.tsp
new file mode 100644
index 00000000..60e020aa
--- /dev/null
+++ b/schema/model/wire/anthropic.tsp
@@ -0,0 +1,22 @@
+import "prompty-emitter";
+import "../model/model.tsp";
+import "../model/usage.tsp";
+
+using Prompty;
+
+// ============================================================================
+// Anthropic Messages API wire mappings
+// https://docs.anthropic.com/en/api/messages
+// ============================================================================
+
+// ModelOptions → Anthropic parameter names
+// Identity mappings included so strict toWire() knows which fields Anthropic supports
+@@knownAs(ModelOptions.temperature, "anthropic", "temperature");
+@@knownAs(ModelOptions.maxOutputTokens, "anthropic", "max_tokens");
+@@knownAs(ModelOptions.topK, "anthropic", "top_k");
+@@knownAs(ModelOptions.topP, "anthropic", "top_p");
+@@knownAs(ModelOptions.stopSequences, "anthropic", "stop_sequences");
+
+// TokenUsage → Anthropic usage field names
+@@knownAs(TokenUsage.promptTokens, "anthropic", "input_tokens");
+@@knownAs(TokenUsage.completionTokens, "anthropic", "output_tokens");
diff --git a/schema/model/wire/openai.tsp b/schema/model/wire/openai.tsp
new file mode 100644
index 00000000..a36679ed
--- /dev/null
+++ b/schema/model/wire/openai.tsp
@@ -0,0 +1,32 @@
+import "prompty-emitter";
+import "../model/model.tsp";
+import "../model/usage.tsp";
+
+using Prompty;
+
+// ============================================================================
+// OpenAI Chat Completions API wire mappings
+// https://platform.openai.com/docs/api-reference/chat/create
+// ============================================================================
+
+// ModelOptions → OpenAI parameter names
+// Identity mappings included so strict toWire() knows which fields OpenAI supports
+@@knownAs(ModelOptions.temperature, "openai", "temperature");
+@@knownAs(ModelOptions.maxOutputTokens, "openai", "max_completion_tokens");
+@@knownAs(ModelOptions.frequencyPenalty, "openai", "frequency_penalty");
+@@knownAs(ModelOptions.presencePenalty, "openai", "presence_penalty");
+@@knownAs(ModelOptions.topP, "openai", "top_p");
+@@knownAs(ModelOptions.topK, "openai", "top_k");
+@@knownAs(ModelOptions.stopSequences, "openai", "stop");
+@@knownAs(ModelOptions.seed, "openai", "seed");
+@@knownAs(ModelOptions.allowMultipleToolCalls, "openai", "parallel_tool_calls");
+
+// ModelOptions → OpenAI Responses API parameter names
+@@knownAs(ModelOptions.temperature, "responses", "temperature");
+@@knownAs(ModelOptions.maxOutputTokens, "responses", "max_output_tokens");
+@@knownAs(ModelOptions.topP, "responses", "top_p");
+
+// TokenUsage → OpenAI usage field names
+@@knownAs(TokenUsage.promptTokens, "openai", "prompt_tokens");
+@@knownAs(TokenUsage.completionTokens, "openai", "completion_tokens");
+@@knownAs(TokenUsage.totalTokens, "openai", "total_tokens");
diff --git a/schema/package-lock.json b/schema/package-lock.json
index f2ba033d..528f0132 100644
--- a/schema/package-lock.json
+++ b/schema/package-lock.json
@@ -8,24 +8,22 @@
       "dependencies": {
         "@typespec/compiler": "latest",
         "@typespec/json-schema": "latest",
-        "agentschema-emitter": "file:./emitter"
+        "prompty-emitter": "file:./emitter"
       }
     },
     "emitter": {
-      "name": "agentschema-emitter",
+      "name": "prompty-emitter",
       "version": "0.2.0",
       "license": "MIT",
       "dependencies": {
-        "nunjucks": "^3.2.4",
         "xml-formatter": "^3.6.7",
         "yaml": "^2.8.1"
       },
       "bin": {
-        "agentschema-generate": "dist/src/cli.js"
+        "prompty-generate": "dist/src/cli.js"
       },
       "devDependencies": {
         "@types/node": "^24.7.0",
-        "@types/nunjucks": "^3.2.6",
         "@typescript-eslint/eslint-plugin": "^8.15.0",
         "@typescript-eslint/parser": "^8.15.0",
         "@typespec/compiler": "latest",
@@ -778,13 +776,6 @@
         "undici-types": "~7.16.0"
       }
     },
-    "node_modules/@types/nunjucks": {
-      "version": "3.2.6",
-      "resolved": "https://registry.npmjs.org/@types/nunjucks/-/nunjucks-3.2.6.tgz",
-      "integrity": "sha512-pHiGtf83na1nCzliuAdq8GowYiXvH5l931xZ0YEHaLMNFgynpEqx+IPStlu7UaDkehfvl01e4x/9Tpwhy7Ue3w==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@types/unist": {
       "version": "2.0.11",
       "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
@@ -1087,12 +1078,6 @@
         "@typespec/compiler": "^1.10.0"
       }
     },
-    "node_modules/a-sync-waterfall": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/a-sync-waterfall/-/a-sync-waterfall-1.0.1.tgz",
-      "integrity": "sha512-RYTOHHdWipFUliRFMCS4X2Yn2X8M87V/OpSqWzKKOGhzqyUxzyVmhHDH9sAvG+ZuQf/TAOFsLCpMw09I1ufUnA==",
-      "license": "MIT"
-    },
     "node_modules/acorn": {
       "version": "8.16.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
@@ -1117,10 +1102,6 @@
         "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
-    "node_modules/agentschema-emitter": {
-      "resolved": "emitter",
-      "link": true
-    },
     "node_modules/ajv": {
       "version": "8.18.0",
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
@@ -1168,12 +1149,6 @@
       "dev": true,
       "license": "Python-2.0"
     },
-    "node_modules/asap": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz",
-      "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==",
-      "license": "MIT"
-    },
     "node_modules/balanced-match": {
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
@@ -3046,40 +3021,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/nunjucks": {
-      "version": "3.2.4",
-      "resolved": "https://registry.npmjs.org/nunjucks/-/nunjucks-3.2.4.tgz",
-      "integrity": "sha512-26XRV6BhkgK0VOxfbU5cQI+ICFUtMLixv1noZn1tGU38kQH5A5nmmbk/O45xdyBhD1esk47nKrY0mvQpZIhRjQ==",
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "a-sync-waterfall": "^1.0.0",
-        "asap": "^2.0.3",
-        "commander": "^5.1.0"
-      },
-      "bin": {
-        "nunjucks-precompile": "bin/precompile"
-      },
-      "engines": {
-        "node": ">= 6.9.0"
-      },
-      "peerDependencies": {
-        "chokidar": "^3.3.0"
-      },
-      "peerDependenciesMeta": {
-        "chokidar": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/nunjucks/node_modules/commander": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
-      "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 6"
-      }
-    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -3226,6 +3167,10 @@
         "url": "https://github.com/prettier/prettier?sponsor=1"
       }
     },
+    "node_modules/prompty-emitter": {
+      "resolved": "emitter",
+      "link": true
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
diff --git a/schema/package.json b/schema/package.json
index f45cd758..74a1a93c 100644
--- a/schema/package.json
+++ b/schema/package.json
@@ -4,11 +4,13 @@
   "description": "TypeSpec models and code generation for Prompty",
   "scripts": {
     "build:emitter": "cd emitter && npm run build",
+    "format:tsp": "npx tsp format \"model/**/*.tsp\"",
+    "format:tsp:check": "npx tsp format \"model/**/*.tsp\" --check",
     "generate": "npx tsp compile model/main.tsp --config tspconfig.yaml",
-    "build": "npm run build:emitter && npm run generate"
+    "build": "npm run build:emitter && npm run format:tsp && npm run generate"
   },
   "dependencies": {
-    "agentschema-emitter": "file:./emitter",
+    "prompty-emitter": "file:./emitter",
     "@typespec/compiler": "latest",
     "@typespec/json-schema": "latest"
   }
diff --git a/schema/tspconfig.yaml b/schema/tspconfig.yaml
index f0f1ceb7..680a1db2 100644
--- a/schema/tspconfig.yaml
+++ b/schema/tspconfig.yaml
@@ -1,13 +1,13 @@
 emit:
   - "@typespec/json-schema"
-  - "agentschema-emitter"
+  - "prompty-emitter"
 options:
   "@typespec/json-schema":
     emitter-output-dir: "{cwd}/../vscode/prompty/schemas"
     emitAllModels: true
     emitAllRefs: true
     file-type: yaml
-  "agentschema-emitter":
+  "prompty-emitter":
     emitter-output-dir: "{cwd}/tsp-output"
     root-object: "Prompty.Prompty"
     emit-targets:
@@ -26,6 +26,7 @@ options:
       - type: Go
         output-dir: "../runtime/go/prompty/model"
         test-dir: "../runtime/go/prompty/model"
+        import-path: "prompty/model"
       - type: Rust
         output-dir: "../runtime/rust/prompty/src/model"
         test-dir: "../runtime/rust/prompty/tests/model"
diff --git a/spec/spec.md b/spec/spec.md
index f646ca7e..5970123f 100644
--- a/spec/spec.md
+++ b/spec/spec.md
@@ -1219,10 +1219,14 @@ function parse(agent, rendered):
 
 ### §6.5 Message Structure
 
+The `Message`, `ContentPart`, `ToolCall`, and `ToolResult` types are defined in the
+TypeSpec schema (`schema/model/message.tsp`) and generated to all runtime languages.
+The canonical type definitions live there; this section specifies behavioral requirements.
+
 ```
 Message:
-  role:     string           // "system" | "user" | "assistant"
-  content:  ContentPart[]    // List of content parts
+  role:     Role             // "system" | "user" | "assistant" | "developer" | "tool"
+  parts:    ContentPart[]    // List of content parts
   metadata: dict | null      // Optional attributes from role markers
 
 ContentPart = TextPart | ImagePart | AudioPart | FilePart
@@ -1233,21 +1237,34 @@ TextPart:
 
 ImagePart:
   kind:      "image"
-  value:     string           // URL or base64-encoded data
+  source:    string           // URL or base64-encoded data
   mediaType: string | null    // MIME type (e.g., "image/png")
   detail:    string | null    // Detail level (e.g., "auto", "low", "high")
 
 AudioPart:
   kind:      "audio"
-  value:     string           // URL or base64-encoded data
+  source:    string           // URL or base64-encoded data
   mediaType: string | null    // MIME type (e.g., "audio/wav")
 
 FilePart:
   kind:      "file"
-  value:     string           // URL or base64-encoded data
+  source:    string           // URL or base64-encoded data
   mediaType: string | null    // MIME type
+
+ToolCall:
+  id:        string           // Unique identifier from the LLM
+  name:      string           // Tool function name
+  arguments: string           // Serialized JSON arguments
+
+ToolResult:
+  parts:     ContentPart[]    // Rich content from tool execution
 ```
 
+**ToolResult** enables tools to return rich content (text, images, files, audio)
+rather than plain strings. Implementations MUST support conversion from a plain
+string to a `ToolResult` containing a single `TextPart` for backward compatibility
+with existing tool handlers that return strings.
+
 ### §6.6 Content Handling Rules
 
 **Blank line trimming**: Leading and trailing blank lines within each message's content
@@ -2254,7 +2271,7 @@ function turn(agent_or_path, inputs, tools=null) → result:
         try:
           if handler is not null:
             // Name registry hit — direct call
-            tool_result = handler(args)
+            tool_result = handler(args)    // returns ToolResult
           else:
             // Layer 2: kind handler fallback
             kind_handler = get_tool_handler(tool_def.kind)
@@ -2263,13 +2280,14 @@ function turn(agent_or_path, inputs, tools=null) → result:
                 "No handler registered for tool: " + tool_call.name
                 + " (kind: " + tool_def.kind + ")"
               )
-            tool_result = kind_handler(tool_def, args, agent, inputs)
+            tool_result = kind_handler(tool_def, args, agent, inputs)  // returns ToolResult
         catch error:
           // Tool handler failures MUST NOT kill the agent loop (§9.9)
-          tool_result = "Error: Tool '" + tool_call.name + "' failed: " + str(error)
-          emit event("error", { message: tool_result })
+          error_text = "Error: Tool '" + tool_call.name + "' failed: " + str(error)
+          tool_result = ToolResult(parts: [TextPart(kind: "text", value: error_text)])
+          emit event("error", { message: error_text })
 
-        tool_results.append({ tool_call_id: tool_call.id, result: str(tool_result) })
+        tool_results.append({ tool_call_id: tool_call.id, result: tool_result })
 
       // Delegate message formatting to the executor (§9.4)
       executor = get_executor(agent.model.provider)
@@ -2342,7 +2360,7 @@ executor.FormatToolMessages(
 | -------------- | ----------------------------- | ------------------------------------------------------ |
 | `raw_response` | provider response or null     | Original API response object; needed by Anthropic to preserve content blocks. May be null in streaming path. |
 | `tool_calls`   | list of `{ id, name, arguments }` | Normalized tool call data extracted from the response. `arguments` is a JSON string. |
-| `tool_results` | list of `{ tool_call_id, result }` | Results from executing each tool, in the same order as `tool_calls`. |
+| `tool_results` | list of `{ tool_call_id, result: ToolResult }` | Results from executing each tool, in the same order as `tool_calls`. Each `result` is a `ToolResult` containing `ContentPart[]`. |
 | `text_content` | string or null                | Any text content from the response alongside tool calls (e.g., Anthropic thinking text). |
 
 **Return value:** A `list<Message>` to append to the conversation. The number
@@ -2379,12 +2397,23 @@ Returns 1 assistant message + N tool messages (one per tool call):
       }
     ]
   },
-  // One tool message per result
+  // One tool message per result — content is derived from ToolResult.parts
+  // If all parts are TextPart, content is a plain string (concatenated)
+  // If parts include non-text (ImagePart, etc.), content is an array:
   {
     role: "tool",
-    content: "72°F and sunny",
+    content: "72°F and sunny",   // simple case: single TextPart → string
     tool_call_id: "call_123"
   }
+  // Rich case (text + image):
+  // {
+  //   role: "tool",
+  //   content: [
+  //     { type: "text", text: "Here's the weather:" },
+  //     { type: "image_url", image_url: { url: "https://..." } }
+  //   ],
+  //   tool_call_id: "call_456"
+  // }
 ]
 ```
 
@@ -2399,11 +2428,17 @@ Returns 1 assistant message + 1 user message (batched tool results):
     role: "assistant",
     content: [<original content blocks from API response>]
   },
-  // ALL tool results in ONE user message
+  // ALL tool results in ONE user message — each result's ContentPart[]
+  // maps to Anthropic content blocks
   {
     role: "user",
     content: [
       { type: "tool_result", tool_use_id: "toolu_123", content: "72°F and sunny" },
+      // Rich result (text + image):
+      // { type: "tool_result", tool_use_id: "toolu_456", content: [
+      //   { type: "text", text: "Here's the chart:" },
+      //   { type: "image", source: { type: "base64", media_type: "image/png", data: "..." } }
+      // ] }
       { type: "tool_result", tool_use_id: "toolu_456", content: "Pizza Palace" }
     ]
   }
@@ -2460,25 +2495,28 @@ parameter name.
 
 ### §9.7 PromptyTool Execution
 
-A `PromptyTool` references another `.prompty` file to be invoked as a tool:
+A `PromptyTool` references another `.prompty` file to be invoked as a tool.
+PromptyTool is **always single-shot** — one LLM call, no agent loop.
 
 ```
-function execute_prompty_tool(tool, args, parent_inputs) → result:
+function execute_prompty_tool(tool, args, parent_inputs) → ToolResult:
   // Resolve path relative to the parent .prompty file
   child_agent = load(tool.path)
 
   // Merge: LLM-provided args + bindings from parent inputs
   merged = apply_bindings(tool, args, parent_inputs)
 
-  match tool.mode:
-    "single":
-      // One LLM call — no agent loop
-      return run(child_agent, merged)
-    "agentic":
-      // Full agent loop — child may call tools too
-      return turn(child_agent, merged, tools=child_agent_tools)
+  // Single-shot execution — invoke, not turn
+  result = invoke(child_agent, merged)
+  return ToolResult(parts: [TextPart(kind: "text", value: str(result))])
 ```
 
+Implementations MUST NOT run an agent loop for `kind: prompty` tools.
+Applications that need agentic sub-agent delegation SHOULD register
+`kind: function` tools that internally call `turn()` with their own
+`TurnOptions`. This keeps policy decisions (event propagation, cancellation,
+steering scope, guardrail inheritance) in application code where they belong.
+
 Child `PromptyTool` execution MUST inherit the parent's tracer registry,
 producing nested trace spans that show the full call hierarchy.
 
@@ -3147,17 +3185,23 @@ and coordination without coupling the loop to any particular output mechanism.
 
 **Event Types:**
 
+The `AgentEventType` enum is defined in TypeSpec (`schema/model/events.tsp`) and
+generated to all runtime languages. The event types and their payloads are:
+
 | Event Type          | Payload                                          | When Emitted                              |
 | ------------------- | ------------------------------------------------ | ----------------------------------------- |
 | `token`             | `{ token: string }`                              | Each content chunk during streaming       |
 | `thinking`          | `{ token: string }`                              | Each reasoning/chain-of-thought chunk     |
 | `tool_call_start`   | `{ name: string, arguments: string }`            | When a tool call is detected              |
-| `tool_result`       | `{ name: string, result: string }`               | After a tool call completes               |
+| `tool_result`       | `{ name: string, result: ToolResult }`           | After a tool call completes               |
 | `status`            | `{ message: string }`                            | Human-readable status updates             |
 | `messages_updated`  | `{ messages: Message[] }`                        | After messages list is mutated            |
 | `done`              | `{ response: string, messages: Message[] }`      | Final response produced                   |
 | `error`             | `{ message: string }`                            | Non-fatal error (e.g., tool panic)        |
 | `cancelled`         | `{}`                                             | Loop was cancelled via cancellation token |
+| `compaction_start`  | `{}`                                             | Context compaction beginning              |
+| `compaction_complete` | `{ removed: int, remaining: int }`             | Context compaction completed              |
+| `compaction_failed` | `{ message: string }`                            | Context compaction failed                 |
 
 **API:**
 
@@ -3422,6 +3466,17 @@ Steering enables external code to inject user messages into a running agent
 loop. This supports interactive scenarios where a user wants to redirect
 the agent mid-execution (e.g., "actually focus on error handling").
 
+**Principle:** Steering is for managing whatever the current agent is doing.
+Steering messages are local to the agent that receives them — they affect
+the current conversation, not sub-agent invocations or child tool calls.
+
+**Normative Requirements:**
+
+- Steering messages MUST be processed between iterations of the agent loop.
+- Steering MUST NOT interrupt in-progress tool execution.
+- Steering MUST NOT propagate to sub-agents (including `kind: prompty` tool invocations).
+- Implementations MUST NOT make implicit LLM calls to route or transform steering messages.
+
 **Steering Queue:**
 
 ```
@@ -3744,4 +3799,70 @@ for (const userInput of messages) {
 
 ---
 
-*End of Specification (Sections 1–14).*
\ No newline at end of file
+## §15 Model Discovery
+
+### §15.1 Overview
+
+Provider packages SHOULD implement a model discovery function that lists
+available models and their capabilities. This enables applications to build
+model selection UIs, validate model configuration, and make runtime decisions
+based on model properties (e.g., context window size, supported modalities).
+
+Model discovery is a **convention**, not a hard requirement. A conforming
+Prompty implementation MAY omit model discovery entirely. However, provider
+packages that support model discovery SHOULD follow the patterns in this section.
+
+### §15.2 ModelInfo Type
+
+The `ModelInfo` type is defined in TypeSpec (`schema/model/discovery.tsp`)
+and generated to all runtime languages. It represents information about a
+single model:
+
+```
+ModelInfo:
+  id:                   string           // Model identifier (e.g., "gpt-4o")
+  displayName:          string | null    // Human-readable name
+  ownedBy:              string | null    // Organization that owns the model
+  contextWindow:        int32 | null     // Maximum context window in tokens
+  inputModalities:      string[] | null  // Accepted modalities ("text", "image", "audio")
+  outputModalities:     string[] | null  // Produced modalities ("text", "audio")
+  additionalProperties: dict | null      // Provider-specific properties
+```
+
+### §15.3 Convention
+
+Each provider package SHOULD implement:
+
+```
+function list_models(connection) → ModelInfo[]:
+  // Call the provider's model listing API
+  // Map results to ModelInfo objects
+  // Enrich with known model properties where the API is sparse
+```
+
+**Provider API Variance:**
+
+| Provider  | API                    | Context Window | Modalities | Notes                        |
+| --------- | ---------------------- | -------------- | ---------- | ---------------------------- |
+| OpenAI    | `GET /v1/models`       | ❌              | ❌          | Sparse — enrich from lookup  |
+| Azure     | `GET /openai/models`   | ✅              | ❌          | Has `max_context_length`     |
+| Anthropic | `GET /v1/models`       | ✅              | ✅          | Rich — `context_length`, modalities |
+
+**Enrichment Strategy:**
+
+Providers with sparse APIs (particularly OpenAI) SHOULD maintain a built-in
+lookup table of known models to enrich the API response. Unknown models get
+`null` for enrichment fields. The lookup table is a best-effort cache — it
+does not need to be exhaustive or always up-to-date.
+
+### §15.4 Conformance
+
+- Provider packages SHOULD implement `list_models(connection) → ModelInfo[]`.
+- Implementations MUST use the TypeSpec-generated `ModelInfo` type.
+- Implementations SHOULD populate as many fields as the provider's API supports.
+- Implementations MAY enrich sparse results from a built-in lookup table.
+- Implementations MUST NOT require model discovery for normal prompt execution.
+
+---
+
+*End of Specification (Sections 1–15).*
\ No newline at end of file
diff --git a/spec/vectors/load/load_vectors.json b/spec/vectors/load/load_vectors.json
index b232154b..5bd6fbc8 100644
--- a/spec/vectors/load/load_vectors.json
+++ b/spec/vectors/load/load_vectors.json
@@ -428,15 +428,14 @@
           {
             "name": "helper",
             "kind": "prompty",
-            "path": "./helper.prompty",
-            "mode": "single"
+            "path": "./helper.prompty"
           }
         ]
       }
     },
     "expected": {
       "tools": [
-        { "name": "helper", "kind": "prompty", "path": "./helper.prompty", "mode": "single" }
+        { "name": "helper", "kind": "prompty", "path": "./helper.prompty" }
       ]
     }
   },
diff --git a/vscode/prompty/schemas/AudioPart.yaml b/vscode/prompty/schemas/AudioPart.yaml
new file mode 100644
index 00000000..85644cbb
--- /dev/null
+++ b/vscode/prompty/schemas/AudioPart.yaml
@@ -0,0 +1,20 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: AudioPart.yaml
+type: object
+properties:
+  kind:
+    type: string
+    const: audio
+    description: The kind identifier for audio content
+  source:
+    type: string
+    description: URL or base64-encoded audio data
+  mediaType:
+    type: string
+    description: MIME type of the audio (e.g., 'audio/wav')
+required:
+  - kind
+  - source
+allOf:
+  - $ref: ContentPart.yaml
+description: An audio content part. The source may be a URL or base64-encoded data.
diff --git a/vscode/prompty/schemas/CompactionCompletePayload.yaml b/vscode/prompty/schemas/CompactionCompletePayload.yaml
new file mode 100644
index 00000000..cdf0551f
--- /dev/null
+++ b/vscode/prompty/schemas/CompactionCompletePayload.yaml
@@ -0,0 +1,18 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: CompactionCompletePayload.yaml
+type: object
+properties:
+  removed:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    description: Number of messages removed during compaction
+  remaining:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    description: Number of messages remaining after compaction
+required:
+  - removed
+  - remaining
+description: Payload for "compaction_complete" events — context compaction finished.
diff --git a/vscode/prompty/schemas/CompactionConfig.yaml b/vscode/prompty/schemas/CompactionConfig.yaml
new file mode 100644
index 00000000..1dab94a5
--- /dev/null
+++ b/vscode/prompty/schemas/CompactionConfig.yaml
@@ -0,0 +1,19 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: CompactionConfig.yaml
+type: object
+properties:
+  strategy:
+    type: string
+    description: The compaction strategy identifier. Built-in strategies include 'summarize'. Can also be a path to a .prompty file used as the summarization prompt.
+  budget:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    description: Character budget for the compacted context. Overrides TurnOptions.contextBudget when set.
+  options:
+    $ref: RecordUnknown.yaml
+    description: Additional strategy-specific options
+description: |-
+  Configuration for context window compaction. When the message history
+  exceeds the context budget, the compaction strategy is applied to
+  reduce the message list while preserving essential information.
diff --git a/vscode/prompty/schemas/CompactionFailedPayload.yaml b/vscode/prompty/schemas/CompactionFailedPayload.yaml
new file mode 100644
index 00000000..4846570a
--- /dev/null
+++ b/vscode/prompty/schemas/CompactionFailedPayload.yaml
@@ -0,0 +1,10 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: CompactionFailedPayload.yaml
+type: object
+properties:
+  message:
+    type: string
+    description: Explanation of why compaction failed
+required:
+  - message
+description: Payload for "compaction_failed" events — compaction could not be completed.
diff --git a/vscode/prompty/schemas/ContentPart.yaml b/vscode/prompty/schemas/ContentPart.yaml
new file mode 100644
index 00000000..85755ea7
--- /dev/null
+++ b/vscode/prompty/schemas/ContentPart.yaml
@@ -0,0 +1,20 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ContentPart.yaml
+type: object
+properties:
+  kind:
+    anyOf:
+      - type: string
+        const: text
+      - type: string
+        const: image
+      - type: string
+        const: file
+      - type: string
+        const: audio
+    description: The kind of content part
+required:
+  - kind
+description: |-
+  A part of a message's content. Content parts are discriminated on the `kind`
+  field and represent the different modalities that can appear in a message.
diff --git a/vscode/prompty/schemas/DoneEventPayload.yaml b/vscode/prompty/schemas/DoneEventPayload.yaml
new file mode 100644
index 00000000..e5275ae2
--- /dev/null
+++ b/vscode/prompty/schemas/DoneEventPayload.yaml
@@ -0,0 +1,16 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: DoneEventPayload.yaml
+type: object
+properties:
+  response:
+    type: string
+    description: The final text response from the LLM
+  messages:
+    type: array
+    items:
+      $ref: Message.yaml
+    description: The final conversation state including all messages
+required:
+  - response
+  - messages
+description: Payload for "done" events — the agent loop completed successfully.
diff --git a/vscode/prompty/schemas/ErrorChunk.yaml b/vscode/prompty/schemas/ErrorChunk.yaml
new file mode 100644
index 00000000..e19ee890
--- /dev/null
+++ b/vscode/prompty/schemas/ErrorChunk.yaml
@@ -0,0 +1,17 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ErrorChunk.yaml
+type: object
+properties:
+  kind:
+    type: string
+    const: error
+    description: The kind identifier for error chunks
+  message:
+    type: string
+    description: The error message
+required:
+  - kind
+  - message
+allOf:
+  - $ref: StreamChunk.yaml
+description: An error chunk from the LLM response stream.
diff --git a/vscode/prompty/schemas/ErrorEventPayload.yaml b/vscode/prompty/schemas/ErrorEventPayload.yaml
new file mode 100644
index 00000000..dd95d5d5
--- /dev/null
+++ b/vscode/prompty/schemas/ErrorEventPayload.yaml
@@ -0,0 +1,10 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ErrorEventPayload.yaml
+type: object
+properties:
+  message:
+    type: string
+    description: Human-readable error description
+required:
+  - message
+description: Payload for "error" events — an error occurred during the loop.
diff --git a/vscode/prompty/schemas/Executor.yaml b/vscode/prompty/schemas/Executor.yaml
new file mode 100644
index 00000000..a74fdeb6
--- /dev/null
+++ b/vscode/prompty/schemas/Executor.yaml
@@ -0,0 +1,5 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: Executor.yaml
+type: object
+properties: {}
+description: Calls an LLM provider with messages and returns the raw provider response.
diff --git a/vscode/prompty/schemas/FilePart.yaml b/vscode/prompty/schemas/FilePart.yaml
new file mode 100644
index 00000000..89fd261d
--- /dev/null
+++ b/vscode/prompty/schemas/FilePart.yaml
@@ -0,0 +1,20 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: FilePart.yaml
+type: object
+properties:
+  kind:
+    type: string
+    const: file
+    description: The kind identifier for file content
+  source:
+    type: string
+    description: URL or base64-encoded file data
+  mediaType:
+    type: string
+    description: MIME type of the file (e.g., 'application/pdf')
+required:
+  - kind
+  - source
+allOf:
+  - $ref: ContentPart.yaml
+description: A file content part. The source may be a URL or base64-encoded data.
diff --git a/vscode/prompty/schemas/GuardrailResult.yaml b/vscode/prompty/schemas/GuardrailResult.yaml
new file mode 100644
index 00000000..84cc67fd
--- /dev/null
+++ b/vscode/prompty/schemas/GuardrailResult.yaml
@@ -0,0 +1,18 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: GuardrailResult.yaml
+type: object
+properties:
+  allowed:
+    type: boolean
+    description: Whether the content passed the guardrail check
+  reason:
+    type: string
+    description: Explanation of why the content was allowed or denied
+  rewrite:
+    description: Optional rewritten content to replace the original
+required:
+  - allowed
+description: |-
+  The result of a guardrail evaluation. Guardrails are safety checks that
+  run at specific phases of the agent loop and can allow, deny, or rewrite
+  content.
diff --git a/vscode/prompty/schemas/ImagePart.yaml b/vscode/prompty/schemas/ImagePart.yaml
new file mode 100644
index 00000000..7064bde0
--- /dev/null
+++ b/vscode/prompty/schemas/ImagePart.yaml
@@ -0,0 +1,23 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ImagePart.yaml
+type: object
+properties:
+  kind:
+    type: string
+    const: image
+    description: The kind identifier for image content
+  source:
+    type: string
+    description: URL or base64-encoded image data
+  detail:
+    type: string
+    description: Detail level hint for the model (e.g., 'auto', 'low', 'high')
+  mediaType:
+    type: string
+    description: MIME type of the image (e.g., 'image/png')
+required:
+  - kind
+  - source
+allOf:
+  - $ref: ContentPart.yaml
+description: An image content part. The source may be a URL or base64-encoded data.
diff --git a/vscode/prompty/schemas/Message.yaml b/vscode/prompty/schemas/Message.yaml
new file mode 100644
index 00000000..85a429d0
--- /dev/null
+++ b/vscode/prompty/schemas/Message.yaml
@@ -0,0 +1,34 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: Message.yaml
+type: object
+properties:
+  role:
+    anyOf:
+      - type: string
+        const: system
+      - type: string
+        const: user
+      - type: string
+        const: assistant
+      - type: string
+        const: developer
+      - type: string
+        const: tool
+    default: user
+    description: The role of the message sender
+  parts:
+    type: array
+    items:
+      $ref: ContentPart.yaml
+    description: The content parts of the message
+  metadata:
+    $ref: RecordUnknown.yaml
+    default: {}
+    description: Optional metadata associated with the message
+required:
+  - role
+  - parts
+  - metadata
+description: |-
+  A message in a conversation. Messages have a role and a list of content parts
+  representing the different modalities of the message content.
diff --git a/vscode/prompty/schemas/MessagesUpdatedPayload.yaml b/vscode/prompty/schemas/MessagesUpdatedPayload.yaml
new file mode 100644
index 00000000..ba647364
--- /dev/null
+++ b/vscode/prompty/schemas/MessagesUpdatedPayload.yaml
@@ -0,0 +1,12 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: MessagesUpdatedPayload.yaml
+type: object
+properties:
+  messages:
+    type: array
+    items:
+      $ref: Message.yaml
+    description: The current full message list after the update
+required:
+  - messages
+description: Payload for "messages_updated" events — the conversation state has changed.
diff --git a/vscode/prompty/schemas/ModelInfo.yaml b/vscode/prompty/schemas/ModelInfo.yaml
new file mode 100644
index 00000000..b2df752f
--- /dev/null
+++ b/vscode/prompty/schemas/ModelInfo.yaml
@@ -0,0 +1,40 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ModelInfo.yaml
+type: object
+properties:
+  id:
+    type: string
+    description: The model identifier (e.g., 'gpt-4o', 'claude-3-opus')
+  displayName:
+    type: string
+    description: Human-readable display name
+  ownedBy:
+    type: string
+    description: The organization or entity that owns the model
+  contextWindow:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    description: Maximum context window size in tokens
+  inputModalities:
+    type: array
+    items:
+      type: string
+    description: Input modalities the model accepts (e.g., 'text', 'image', 'audio')
+  outputModalities:
+    type: array
+    items:
+      type: string
+    description: Output modalities the model can produce (e.g., 'text', 'audio')
+  additionalProperties:
+    $ref: RecordUnknown.yaml
+    description: Additional provider-specific properties
+required:
+  - id
+description: |-
+  Information about a model available from a provider. Used by provider-level
+  model discovery to report which models are available and their capabilities.
+
+  Not all providers return all fields — implementations SHOULD populate as
+  many fields as the provider's API supports and MAY enrich sparse results
+  from a built-in lookup table of known models.
diff --git a/vscode/prompty/schemas/Parser.yaml b/vscode/prompty/schemas/Parser.yaml
new file mode 100644
index 00000000..9526f85d
--- /dev/null
+++ b/vscode/prompty/schemas/Parser.yaml
@@ -0,0 +1,5 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: Parser.yaml
+type: object
+properties: {}
+description: Parses rendered prompt text into an array of structured messages with role markers.
diff --git a/vscode/prompty/schemas/Processor.yaml b/vscode/prompty/schemas/Processor.yaml
new file mode 100644
index 00000000..0a0d057b
--- /dev/null
+++ b/vscode/prompty/schemas/Processor.yaml
@@ -0,0 +1,5 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: Processor.yaml
+type: object
+properties: {}
+description: Extracts a clean, typed result from a raw LLM provider response.
diff --git a/vscode/prompty/schemas/Renderer.yaml b/vscode/prompty/schemas/Renderer.yaml
new file mode 100644
index 00000000..8ca0f47f
--- /dev/null
+++ b/vscode/prompty/schemas/Renderer.yaml
@@ -0,0 +1,5 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: Renderer.yaml
+type: object
+properties: {}
+description: Renders a template string with input values to produce the final prompt text.
diff --git a/vscode/prompty/schemas/StatusEventPayload.yaml b/vscode/prompty/schemas/StatusEventPayload.yaml
new file mode 100644
index 00000000..2b0beadb
--- /dev/null
+++ b/vscode/prompty/schemas/StatusEventPayload.yaml
@@ -0,0 +1,10 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: StatusEventPayload.yaml
+type: object
+properties:
+  message:
+    type: string
+    description: Human-readable status message
+required:
+  - message
+description: Payload for "status" events — informational messages about loop progress.
diff --git a/vscode/prompty/schemas/StreamChunk.yaml b/vscode/prompty/schemas/StreamChunk.yaml
new file mode 100644
index 00000000..5f1776fb
--- /dev/null
+++ b/vscode/prompty/schemas/StreamChunk.yaml
@@ -0,0 +1,20 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: StreamChunk.yaml
+type: object
+properties:
+  kind:
+    anyOf:
+      - type: string
+        const: text
+      - type: string
+        const: thinking
+      - type: string
+        const: tool
+      - type: string
+        const: error
+    description: The kind of stream chunk
+required:
+  - kind
+description: |-
+  A chunk of data from a streaming LLM response. Stream chunks are
+  discriminated on the `kind` field.
diff --git a/vscode/prompty/schemas/TextChunk.yaml b/vscode/prompty/schemas/TextChunk.yaml
new file mode 100644
index 00000000..a51de55a
--- /dev/null
+++ b/vscode/prompty/schemas/TextChunk.yaml
@@ -0,0 +1,17 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: TextChunk.yaml
+type: object
+properties:
+  kind:
+    type: string
+    const: text
+    description: The kind identifier for text chunks
+  value:
+    type: string
+    description: The text content of the chunk
+required:
+  - kind
+  - value
+allOf:
+  - $ref: StreamChunk.yaml
+description: A text content chunk from the LLM response stream.
diff --git a/vscode/prompty/schemas/TextPart.yaml b/vscode/prompty/schemas/TextPart.yaml
new file mode 100644
index 00000000..589918b5
--- /dev/null
+++ b/vscode/prompty/schemas/TextPart.yaml
@@ -0,0 +1,17 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: TextPart.yaml
+type: object
+properties:
+  kind:
+    type: string
+    const: text
+    description: The kind identifier for text content
+  value:
+    type: string
+    description: The text content
+required:
+  - kind
+  - value
+allOf:
+  - $ref: ContentPart.yaml
+description: A text content part.
diff --git a/vscode/prompty/schemas/ThinkingChunk.yaml b/vscode/prompty/schemas/ThinkingChunk.yaml
new file mode 100644
index 00000000..1aca49a3
--- /dev/null
+++ b/vscode/prompty/schemas/ThinkingChunk.yaml
@@ -0,0 +1,17 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ThinkingChunk.yaml
+type: object
+properties:
+  kind:
+    type: string
+    const: thinking
+    description: The kind identifier for thinking chunks
+  value:
+    type: string
+    description: The thinking content of the chunk
+required:
+  - kind
+  - value
+allOf:
+  - $ref: StreamChunk.yaml
+description: A thinking/reasoning content chunk from the LLM response stream.
diff --git a/vscode/prompty/schemas/ThinkingEventPayload.yaml b/vscode/prompty/schemas/ThinkingEventPayload.yaml
new file mode 100644
index 00000000..5f238c7e
--- /dev/null
+++ b/vscode/prompty/schemas/ThinkingEventPayload.yaml
@@ -0,0 +1,10 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ThinkingEventPayload.yaml
+type: object
+properties:
+  token:
+    type: string
+    description: The thinking/reasoning token text
+required:
+  - token
+description: Payload for "thinking" events — reasoning/chain-of-thought tokens.
diff --git a/vscode/prompty/schemas/ThreadMarker.yaml b/vscode/prompty/schemas/ThreadMarker.yaml
new file mode 100644
index 00000000..7b380dad
--- /dev/null
+++ b/vscode/prompty/schemas/ThreadMarker.yaml
@@ -0,0 +1,21 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ThreadMarker.yaml
+type: object
+properties:
+  name:
+    type: string
+    default: thread
+    description: The input property name (e.g. 'conversation')
+  kind:
+    type: string
+    default: thread
+    description: The rich kind ('thread', 'image', 'file', 'audio')
+required:
+  - name
+  - kind
+description: |-
+  Positional marker for conversation history insertion during template rendering.
+
+  During `prepare()`, nonce strings in rendered text are replaced with
+  ThreadMarker objects. The pipeline then replaces them with actual
+  conversation messages from the inputs.
diff --git a/vscode/prompty/schemas/TokenEventPayload.yaml b/vscode/prompty/schemas/TokenEventPayload.yaml
new file mode 100644
index 00000000..054977c0
--- /dev/null
+++ b/vscode/prompty/schemas/TokenEventPayload.yaml
@@ -0,0 +1,10 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: TokenEventPayload.yaml
+type: object
+properties:
+  token:
+    type: string
+    description: The streamed token text
+required:
+  - token
+description: Payload for "token" events — a single text token streamed from the LLM.
diff --git a/vscode/prompty/schemas/TokenUsage.yaml b/vscode/prompty/schemas/TokenUsage.yaml
new file mode 100644
index 00000000..6240ef70
--- /dev/null
+++ b/vscode/prompty/schemas/TokenUsage.yaml
@@ -0,0 +1,23 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: TokenUsage.yaml
+type: object
+properties:
+  promptTokens:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    description: Number of tokens in the prompt/input sent to the model
+  completionTokens:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    description: Number of tokens generated in the model's completion/output
+  totalTokens:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    description: Total tokens consumed (prompt + completion). May be provided by the API or computed.
+description: |-
+  Tracks token consumption for a single LLM call. Provider-specific field
+  names (e.g., OpenAI's `prompt_tokens` vs Anthropic's `input_tokens`)
+  are mapped via `knownAs` augments in the wire directory.
diff --git a/vscode/prompty/schemas/ToolCall.yaml b/vscode/prompty/schemas/ToolCall.yaml
new file mode 100644
index 00000000..33420a02
--- /dev/null
+++ b/vscode/prompty/schemas/ToolCall.yaml
@@ -0,0 +1,20 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ToolCall.yaml
+type: object
+properties:
+  id:
+    type: string
+    description: The unique identifier of the tool call
+  name:
+    type: string
+    description: The name of the tool to call
+  arguments:
+    type: string
+    description: The serialized JSON arguments for the tool call
+required:
+  - id
+  - name
+  - arguments
+description: |-
+  A tool call requested by the LLM. Contains the function name and serialized
+  arguments that should be dispatched to the appropriate tool handler.
diff --git a/vscode/prompty/schemas/ToolCallStartPayload.yaml b/vscode/prompty/schemas/ToolCallStartPayload.yaml
new file mode 100644
index 00000000..d41ce044
--- /dev/null
+++ b/vscode/prompty/schemas/ToolCallStartPayload.yaml
@@ -0,0 +1,14 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ToolCallStartPayload.yaml
+type: object
+properties:
+  name:
+    type: string
+    description: The name of the tool being called
+  arguments:
+    type: string
+    description: The serialized JSON arguments for the tool call
+required:
+  - name
+  - arguments
+description: Payload for "tool_call_start" events — the LLM has requested a tool call.
diff --git a/vscode/prompty/schemas/ToolChunk.yaml b/vscode/prompty/schemas/ToolChunk.yaml
new file mode 100644
index 00000000..21bbc94a
--- /dev/null
+++ b/vscode/prompty/schemas/ToolChunk.yaml
@@ -0,0 +1,17 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ToolChunk.yaml
+type: object
+properties:
+  kind:
+    type: string
+    const: tool
+    description: The kind identifier for tool chunks
+  toolCall:
+    $ref: ToolCall.yaml
+    description: The tool call data
+required:
+  - kind
+  - toolCall
+allOf:
+  - $ref: StreamChunk.yaml
+description: A tool call chunk from the LLM response stream.
diff --git a/vscode/prompty/schemas/ToolContext.yaml b/vscode/prompty/schemas/ToolContext.yaml
new file mode 100644
index 00000000..39ddfe44
--- /dev/null
+++ b/vscode/prompty/schemas/ToolContext.yaml
@@ -0,0 +1,18 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ToolContext.yaml
+type: object
+properties:
+  messages:
+    type: array
+    items:
+      $ref: Message.yaml
+    description: The current conversation messages at the point of tool invocation
+  metadata:
+    $ref: RecordUnknown.yaml
+    description: Optional metadata for tool-specific context (e.g., user session info)
+required:
+  - messages
+description: |-
+  Context passed to tool handlers during agent loop execution. Provides
+  access to the agent configuration, current conversation state, and
+  arbitrary metadata for tool implementations that need broader context.
diff --git a/vscode/prompty/schemas/ToolDispatchResult.yaml b/vscode/prompty/schemas/ToolDispatchResult.yaml
new file mode 100644
index 00000000..c3d01cae
--- /dev/null
+++ b/vscode/prompty/schemas/ToolDispatchResult.yaml
@@ -0,0 +1,21 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ToolDispatchResult.yaml
+type: object
+properties:
+  toolCallId:
+    type: string
+    description: The tool call ID from the LLM response, used to correlate results
+  name:
+    type: string
+    description: The name of the tool that was called
+  result:
+    $ref: ToolResult.yaml
+    description: The result produced by the tool handler
+required:
+  - toolCallId
+  - name
+  - result
+description: |-
+  The result of dispatching a single tool call. Pairs the tool call
+  identifier with the tool's name and result for correlation in the
+  agent loop's message assembly.
diff --git a/vscode/prompty/schemas/ToolResult.yaml b/vscode/prompty/schemas/ToolResult.yaml
new file mode 100644
index 00000000..a4f3a2db
--- /dev/null
+++ b/vscode/prompty/schemas/ToolResult.yaml
@@ -0,0 +1,17 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ToolResult.yaml
+type: object
+properties:
+  parts:
+    type: array
+    items:
+      $ref: ContentPart.yaml
+    description: The content parts of the tool result
+required:
+  - parts
+description: |-
+  The result of a tool execution. Contains a list of content parts, enabling
+  rich tool results (text, images, files, audio) rather than just strings.
+
+  Implementations MUST support conversion from a plain string to a ToolResult
+  containing a single TextPart for backward compatibility.
diff --git a/vscode/prompty/schemas/ToolResultPayload.yaml b/vscode/prompty/schemas/ToolResultPayload.yaml
new file mode 100644
index 00000000..27c016a7
--- /dev/null
+++ b/vscode/prompty/schemas/ToolResultPayload.yaml
@@ -0,0 +1,14 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: ToolResultPayload.yaml
+type: object
+properties:
+  name:
+    type: string
+    description: The name of the tool that produced the result
+  result:
+    $ref: ToolResult.yaml
+    description: The tool's result
+required:
+  - name
+  - result
+description: Payload for "tool_result" events — a tool has returned its result.
diff --git a/vscode/prompty/schemas/TurnOptions.yaml b/vscode/prompty/schemas/TurnOptions.yaml
new file mode 100644
index 00000000..afeca1b5
--- /dev/null
+++ b/vscode/prompty/schemas/TurnOptions.yaml
@@ -0,0 +1,44 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: TurnOptions.yaml
+type: object
+properties:
+  maxIterations:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    default: 10
+    description: Maximum number of tool-call iterations before the loop terminates
+  maxLlmRetries:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    default: 3
+    description: Maximum number of LLM call retries on transient failure within a single iteration
+  contextBudget:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    description: Character budget for the context window. When set, the loop trims older messages to stay within budget before each LLM call. System messages are never dropped.
+  parallelToolCalls:
+    type: boolean
+    default: false
+    description: Whether to execute multiple tool calls concurrently when the LLM returns several in one response
+  raw:
+    type: boolean
+    default: false
+    description: When true, return the raw LLM response without processor post-processing
+  turn:
+    type: integer
+    minimum: -2147483648
+    maximum: 2147483647
+    description: Turn number for trace labeling. Useful when the caller maintains an outer conversation loop.
+  compaction:
+    $ref: CompactionConfig.yaml
+    description: Context compaction configuration. Controls how messages are summarized when the context window exceeds the budget.
+description: |-
+  Configuration for the agent loop's turn() function. Controls iteration
+  limits, retry policy, context management, and execution behavior.
+
+  Runtimes accept these as either a TurnOptions object or individual
+  keyword/named parameters — the TypeSpec model defines the canonical
+  field set.
diff --git a/web/src/content/docs/reference/AnonymousConnection.md b/web/src/content/docs/reference/AnonymousConnection.md
index 88faaf6b..ccdcb240 100644
--- a/web/src/content/docs/reference/AnonymousConnection.md
+++ b/web/src/content/docs/reference/AnonymousConnection.md
@@ -25,7 +25,6 @@ classDiagram
     }
     Connection <|-- AnonymousConnection
     class AnonymousConnection {
-      
         +string kind
         +string endpoint
     }
@@ -42,5 +41,5 @@ endpoint: https://{your-custom-endpoint}.openai.azure.com/
 
 | Name | Type | Description |
 | ---- | ---- | ----------- |
-| kind | string | The Authentication kind for the AI service (e.g., &#39;key&#39; for API key, &#39;oauth&#39; for OAuth tokens) |
+| kind | string | The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens) |
 | endpoint | string | The endpoint for authenticating with the AI service |
diff --git a/web/src/content/docs/reference/ApiKeyConnection.md b/web/src/content/docs/reference/ApiKeyConnection.md
index f72af761..2476ee82 100644
--- a/web/src/content/docs/reference/ApiKeyConnection.md
+++ b/web/src/content/docs/reference/ApiKeyConnection.md
@@ -25,7 +25,6 @@ classDiagram
     }
     Connection <|-- ApiKeyConnection
     class ApiKeyConnection {
-      
         +string kind
         +string endpoint
         +string apiKey
@@ -44,6 +43,6 @@ apiKey: your-api-key
 
 | Name | Type | Description |
 | ---- | ---- | ----------- |
-| kind | string | The Authentication kind for the AI service (e.g., &#39;key&#39; for API key, &#39;oauth&#39; for OAuth tokens) |
+| kind | string | The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens) |
 | endpoint | string | The endpoint URL for the AI service |
 | apiKey | string | The API key for authenticating with the AI service |
diff --git a/web/src/content/docs/reference/ArrayProperty.md b/web/src/content/docs/reference/ArrayProperty.md
index 089a8082..600f9bed 100644
--- a/web/src/content/docs/reference/ArrayProperty.md
+++ b/web/src/content/docs/reference/ArrayProperty.md
@@ -30,7 +30,6 @@ classDiagram
     }
     Property <|-- ArrayProperty
     class ArrayProperty {
-      
         +string kind
         +Property items
     }
diff --git a/web/src/content/docs/reference/AudioPart.md b/web/src/content/docs/reference/AudioPart.md
new file mode 100644
index 00000000..d5d9cc58
--- /dev/null
+++ b/web/src/content/docs/reference/AudioPart.md
@@ -0,0 +1,45 @@
+---
+title: "AudioPart"
+description: "Documentation for the AudioPart type."
+slug: "reference/audiopart"
+---
+
+An audio content part. The source may be a URL or base64-encoded data.
+
+## Class Diagram
+
+```mermaid
+---
+title: AudioPart
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ContentPart {
+        +string kind
+    }
+    ContentPart <|-- AudioPart
+    class AudioPart {
+        +string kind
+        +string source
+        +string mediaType
+    }
+```
+
+## Yaml Example
+
+```yaml
+source: https://example.com/audio.wav
+mediaType: audio/wav
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind identifier for audio content |
+| source | string | URL or base64-encoded audio data |
+| mediaType | string | MIME type of the audio (e.g., 'audio/wav') |
diff --git a/web/src/content/docs/reference/Binding.md b/web/src/content/docs/reference/Binding.md
index 536151ab..b952fc98 100644
--- a/web/src/content/docs/reference/Binding.md
+++ b/web/src/content/docs/reference/Binding.md
@@ -19,7 +19,6 @@ config:
 ---
 classDiagram
     class Binding {
-      
         +string name
         +string input
     }
diff --git a/web/src/content/docs/reference/CompactionCompletePayload.md b/web/src/content/docs/reference/CompactionCompletePayload.md
new file mode 100644
index 00000000..a7b1a961
--- /dev/null
+++ b/web/src/content/docs/reference/CompactionCompletePayload.md
@@ -0,0 +1,39 @@
+---
+title: "CompactionCompletePayload"
+description: "Documentation for the CompactionCompletePayload type."
+slug: "reference/compactioncompletepayload"
+---
+
+Payload for "compaction_complete" events — context compaction finished.
+
+## Class Diagram
+
+```mermaid
+---
+title: CompactionCompletePayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class CompactionCompletePayload {
+        +int32 removed
+        +int32 remaining
+    }
+```
+
+## Yaml Example
+
+```yaml
+removed: 5
+remaining: 3
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| removed | int32 | Number of messages removed during compaction |
+| remaining | int32 | Number of messages remaining after compaction |
diff --git a/web/src/content/docs/reference/CompactionConfig.md b/web/src/content/docs/reference/CompactionConfig.md
new file mode 100644
index 00000000..831f4bf0
--- /dev/null
+++ b/web/src/content/docs/reference/CompactionConfig.md
@@ -0,0 +1,45 @@
+---
+title: "CompactionConfig"
+description: "Documentation for the CompactionConfig type."
+slug: "reference/compactionconfig"
+---
+
+Configuration for context window compaction. When the message history
+exceeds the context budget, the compaction strategy is applied to
+reduce the message list while preserving essential information.
+
+## Class Diagram
+
+```mermaid
+---
+title: CompactionConfig
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class CompactionConfig {
+        +string strategy
+        +int32 budget
+        +dictionary options
+    }
+```
+
+## Yaml Example
+
+```yaml
+strategy: summarize
+budget: 50000
+options:
+  preserveSystemMessages: true
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| strategy | string | The compaction strategy identifier. Built-in strategies include 'summarize'. Can also be a path to a .prompty file used as the summarization prompt. |
+| budget | int32 | Character budget for the compacted context. Overrides TurnOptions.contextBudget when set. |
+| options | dictionary | Additional strategy-specific options |
diff --git a/web/src/content/docs/reference/CompactionFailedPayload.md b/web/src/content/docs/reference/CompactionFailedPayload.md
new file mode 100644
index 00000000..ed8739a0
--- /dev/null
+++ b/web/src/content/docs/reference/CompactionFailedPayload.md
@@ -0,0 +1,36 @@
+---
+title: "CompactionFailedPayload"
+description: "Documentation for the CompactionFailedPayload type."
+slug: "reference/compactionfailedpayload"
+---
+
+Payload for "compaction_failed" events — compaction could not be completed.
+
+## Class Diagram
+
+```mermaid
+---
+title: CompactionFailedPayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class CompactionFailedPayload {
+        +string message
+    }
+```
+
+## Yaml Example
+
+```yaml
+message: Summarization prompt exceeded context window
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| message | string | Explanation of why compaction failed |
diff --git a/web/src/content/docs/reference/Connection.md b/web/src/content/docs/reference/Connection.md
index ca7c0dab..b5a891d6 100644
--- a/web/src/content/docs/reference/Connection.md
+++ b/web/src/content/docs/reference/Connection.md
@@ -79,8 +79,8 @@ usageDescription: This will allow the agent to respond to an email on your behal
 
 | Name | Type | Description |
 | ---- | ---- | ----------- |
-| kind | string | The Authentication kind for the AI service (e.g., &#39;key&#39; for API key, &#39;oauth&#39; for OAuth tokens) |
-| authenticationMode | string | The authority level for the connection, indicating under whose authority the connection is made (e.g., &#39;user&#39;, &#39;agent&#39;, &#39;system&#39;) |
+| kind | string | The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens) |
+| authenticationMode | string | The authority level for the connection, indicating under whose authority the connection is made (e.g., 'user', 'agent', 'system') |
 | usageDescription | string | The usage description for the connection, providing context on how this connection will be used |
 
 ## Child Types
diff --git a/web/src/content/docs/reference/ContentPart.md b/web/src/content/docs/reference/ContentPart.md
new file mode 100644
index 00000000..8a5db699
--- /dev/null
+++ b/web/src/content/docs/reference/ContentPart.md
@@ -0,0 +1,65 @@
+---
+title: "ContentPart"
+description: "Documentation for the ContentPart type."
+slug: "reference/contentpart"
+---
+
+A part of a message's content. Content parts are discriminated on the `kind`
+field and represent the different modalities that can appear in a message.
+
+## Class Diagram
+
+```mermaid
+---
+title: ContentPart
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ContentPart {
+      <<abstract>>
+        +string kind
+    }
+    class TextPart {
+        +string kind
+        +string value
+    }
+    ContentPart <|-- TextPart
+    class ImagePart {
+        +string kind
+        +string source
+        +string detail
+        +string mediaType
+    }
+    ContentPart <|-- ImagePart
+    class FilePart {
+        +string kind
+        +string source
+        +string mediaType
+    }
+    ContentPart <|-- FilePart
+    class AudioPart {
+        +string kind
+        +string source
+        +string mediaType
+    }
+    ContentPart <|-- AudioPart
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind of content part |
+
+## Child Types
+
+The following types extend `ContentPart`:
+
+- [TextPart](../textpart/)
+- [ImagePart](../imagepart/)
+- [FilePart](../filepart/)
+- [AudioPart](../audiopart/)
diff --git a/web/src/content/docs/reference/CustomTool.md b/web/src/content/docs/reference/CustomTool.md
index 74b69dc8..b9a6ee6d 100644
--- a/web/src/content/docs/reference/CustomTool.md
+++ b/web/src/content/docs/reference/CustomTool.md
@@ -30,7 +30,6 @@ classDiagram
     }
     Tool <|-- CustomTool
     class CustomTool {
-      
         +string kind
         +Connection connection
         +dictionary options
diff --git a/web/src/content/docs/reference/DoneEventPayload.md b/web/src/content/docs/reference/DoneEventPayload.md
new file mode 100644
index 00000000..108c46cd
--- /dev/null
+++ b/web/src/content/docs/reference/DoneEventPayload.md
@@ -0,0 +1,50 @@
+---
+title: "DoneEventPayload"
+description: "Documentation for the DoneEventPayload type."
+slug: "reference/doneeventpayload"
+---
+
+Payload for "done" events — the agent loop completed successfully.
+
+## Class Diagram
+
+```mermaid
+---
+title: DoneEventPayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class DoneEventPayload {
+        +string response
+        +Message[] messages
+    }
+    class Message {
+        +string role
+        +ContentPart[] parts
+        +dictionary metadata
+    }
+    DoneEventPayload *-- Message
+```
+
+## Yaml Example
+
+```yaml
+response: The weather in Paris is 72°F and sunny.
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| response | string | The final text response from the LLM |
+| messages | [Message[]](../message/) | The final conversation state including all messages |
+
+## Composed Types
+
+The following types are composed within `DoneEventPayload`:
+
+- [Message](../message/)
diff --git a/web/src/content/docs/reference/ErrorChunk.md b/web/src/content/docs/reference/ErrorChunk.md
new file mode 100644
index 00000000..a9b783a8
--- /dev/null
+++ b/web/src/content/docs/reference/ErrorChunk.md
@@ -0,0 +1,42 @@
+---
+title: "ErrorChunk"
+description: "Documentation for the ErrorChunk type."
+slug: "reference/errorchunk"
+---
+
+An error chunk from the LLM response stream.
+
+## Class Diagram
+
+```mermaid
+---
+title: ErrorChunk
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class StreamChunk {
+        +string kind
+    }
+    StreamChunk <|-- ErrorChunk
+    class ErrorChunk {
+        +string kind
+        +string message
+    }
+```
+
+## Yaml Example
+
+```yaml
+message: Rate limit exceeded
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind identifier for error chunks |
+| message | string | The error message |
diff --git a/web/src/content/docs/reference/ErrorEventPayload.md b/web/src/content/docs/reference/ErrorEventPayload.md
new file mode 100644
index 00000000..a25b9dde
--- /dev/null
+++ b/web/src/content/docs/reference/ErrorEventPayload.md
@@ -0,0 +1,36 @@
+---
+title: "ErrorEventPayload"
+description: "Documentation for the ErrorEventPayload type."
+slug: "reference/erroreventpayload"
+---
+
+Payload for "error" events — an error occurred during the loop.
+
+## Class Diagram
+
+```mermaid
+---
+title: ErrorEventPayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ErrorEventPayload {
+        +string message
+    }
+```
+
+## Yaml Example
+
+```yaml
+message: Rate limit exceeded
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| message | string | Human-readable error description |
diff --git a/web/src/content/docs/reference/ExecuteError.md b/web/src/content/docs/reference/ExecuteError.md
new file mode 100644
index 00000000..ab031b07
--- /dev/null
+++ b/web/src/content/docs/reference/ExecuteError.md
@@ -0,0 +1,62 @@
+---
+title: "ExecuteError"
+description: "Documentation for the ExecuteError type."
+slug: "reference/executeerror"
+---
+
+Data carried by an ExecuteError — raised when the LLM call fails
+after exhausting all retry attempts. Implementations wrap this in
+the language-appropriate exception type while preserving the
+accumulated conversation state for recovery or debugging.
+
+## Class Diagram
+
+```mermaid
+---
+title: ExecuteError
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ExecuteError {
+        +string message
+        +Message[] messages
+    }
+    class Message {
+        +string role
+        +ContentPart[] parts
+        +dictionary metadata
+    }
+    ExecuteError *-- Message
+```
+
+## Yaml Example
+
+```yaml
+message: "LLM call failed after 3 retries: rate limit exceeded"
+messages:
+  - role: system
+    parts:
+      - kind: text
+        value: You are a helpful assistant.
+  - role: user
+    parts:
+      - kind: text
+        value: Hello
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| message | string | Human-readable error description including retry count and underlying cause |
+| messages | [Message[]](../message/) | The full conversation state at the time of failure, enabling the caller to retry with the accumulated messages |
+
+## Composed Types
+
+The following types are composed within `ExecuteError`:
+
+- [Message](../message/)
diff --git a/web/src/content/docs/reference/Executor.md b/web/src/content/docs/reference/Executor.md
new file mode 100644
index 00000000..7e702f31
--- /dev/null
+++ b/web/src/content/docs/reference/Executor.md
@@ -0,0 +1,33 @@
+---
+title: "Executor"
+description: "Documentation for the Executor type."
+slug: "reference/executor"
+---
+
+Calls an LLM provider with messages and returns the raw provider response.
+
+## Class Diagram
+
+```mermaid
+---
+title: Executor
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class Executor {
+    }
+```
+
+## Helper Methods
+
+The following helper methods are declared via `@method` and must be implemented by every runtime. Idiomatic language shape (e.g. zero-param accessor may be a property) is chosen per-language by the emitter.
+
+| Name | Signature | Description |
+| ---- | --------- | ----------- |
+| `execute` | `execute(agent: Prompty, messages: Message[]) -> unknown` | Call an LLM provider with messages and return the raw response |
+| `executeStream` | `executeStream(agent: Prompty, messages: Message[]) -> unknown` _(optional)_ | Call an LLM provider and return a streaming response. Returns a language-specific async iterable/stream of raw chunks. Not all providers support streaming; the default implementation should signal lack of support. |
+| `formatToolMessages` | `formatToolMessages(rawResponse: unknown, toolCalls: ToolCall[], toolResults: string[], textContent: string?) -> Message[]` _(sync)_ | Format tool call results into messages for the next iteration |
diff --git a/web/src/content/docs/reference/FilePart.md b/web/src/content/docs/reference/FilePart.md
new file mode 100644
index 00000000..28b02f6e
--- /dev/null
+++ b/web/src/content/docs/reference/FilePart.md
@@ -0,0 +1,45 @@
+---
+title: "FilePart"
+description: "Documentation for the FilePart type."
+slug: "reference/filepart"
+---
+
+A file content part. The source may be a URL or base64-encoded data.
+
+## Class Diagram
+
+```mermaid
+---
+title: FilePart
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ContentPart {
+        +string kind
+    }
+    ContentPart <|-- FilePart
+    class FilePart {
+        +string kind
+        +string source
+        +string mediaType
+    }
+```
+
+## Yaml Example
+
+```yaml
+source: https://example.com/document.pdf
+mediaType: application/pdf
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind identifier for file content |
+| source | string | URL or base64-encoded file data |
+| mediaType | string | MIME type of the file (e.g., 'application/pdf') |
diff --git a/web/src/content/docs/reference/FormatConfig.md b/web/src/content/docs/reference/FormatConfig.md
index 76c64895..d0b34938 100644
--- a/web/src/content/docs/reference/FormatConfig.md
+++ b/web/src/content/docs/reference/FormatConfig.md
@@ -19,7 +19,6 @@ config:
 ---
 classDiagram
     class FormatConfig {
-      
         +string kind
         +boolean strict
         +dictionary options
@@ -50,7 +49,7 @@ These allow for simplified creation of instances using a single property.
 
 ### string format
 
-Simple construction with just a &quot;kind&quot; string
+Simple construction with just a "kind" string
 
 The following simplified representation can be used:
 
diff --git a/web/src/content/docs/reference/FoundryConnection.md b/web/src/content/docs/reference/FoundryConnection.md
index ce938ce4..2001e1ae 100644
--- a/web/src/content/docs/reference/FoundryConnection.md
+++ b/web/src/content/docs/reference/FoundryConnection.md
@@ -27,7 +27,6 @@ classDiagram
     }
     Connection <|-- FoundryConnection
     class FoundryConnection {
-      
         +string kind
         +string endpoint
         +string name
@@ -51,4 +50,4 @@ connectionType: model
 | kind | string | The connection kind for Foundry project access |
 | endpoint | string | The Foundry project endpoint URL |
 | name | string | The named connection within the Foundry project |
-| connectionType | string | The connection type within the Foundry project (e.g., &#39;model&#39;, &#39;index&#39;, &#39;storage&#39;) |
+| connectionType | string | The connection type within the Foundry project (e.g., 'model', 'index', 'storage') |
diff --git a/web/src/content/docs/reference/FunctionTool.md b/web/src/content/docs/reference/FunctionTool.md
index 806239c9..1082d4e2 100644
--- a/web/src/content/docs/reference/FunctionTool.md
+++ b/web/src/content/docs/reference/FunctionTool.md
@@ -26,7 +26,6 @@ classDiagram
     }
     Tool <|-- FunctionTool
     class FunctionTool {
-      
         +string kind
         +Property[] parameters
         +boolean strict
diff --git a/web/src/content/docs/reference/GuardrailError.md b/web/src/content/docs/reference/GuardrailError.md
new file mode 100644
index 00000000..e7a67400
--- /dev/null
+++ b/web/src/content/docs/reference/GuardrailError.md
@@ -0,0 +1,38 @@
+---
+title: "GuardrailError"
+description: "Documentation for the GuardrailError type."
+slug: "reference/guardrailerror"
+---
+
+Data carried by a GuardrailError — raised when an input or output
+guardrail denies content. The reason field explains the denial
+for logging, UI display, or programmatic handling.
+
+## Class Diagram
+
+```mermaid
+---
+title: GuardrailError
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class GuardrailError {
+        +string reason
+    }
+```
+
+## Yaml Example
+
+```yaml
+reason: Content contains personally identifiable information
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| reason | string | Explanation of why the guardrail denied the content |
diff --git a/web/src/content/docs/reference/GuardrailResult.md b/web/src/content/docs/reference/GuardrailResult.md
new file mode 100644
index 00000000..b61a62d8
--- /dev/null
+++ b/web/src/content/docs/reference/GuardrailResult.md
@@ -0,0 +1,51 @@
+---
+title: "GuardrailResult"
+description: "Documentation for the GuardrailResult type."
+slug: "reference/guardrailresult"
+---
+
+The result of a guardrail evaluation. Guardrails are safety checks that
+run at specific phases of the agent loop and can allow, deny, or rewrite
+content.
+
+## Class Diagram
+
+```mermaid
+---
+title: GuardrailResult
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class GuardrailResult {
+        +boolean allowed
+        +string reason
+        +unknown rewrite
+    }
+```
+
+## Yaml Example
+
+```yaml
+allowed: true
+reason: Content is safe
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| allowed | boolean | Whether the content passed the guardrail check |
+| reason | string | Explanation of why the content was allowed or denied |
+| rewrite | unknown | Optional rewritten content to replace the original |
+
+## Factory Methods
+
+The following factory methods are declared via `@factory` and are generated automatically by the emitter in every language.
+
+- `rewrite(rewrite: unknown)`
+- `deny(reason: string)`
+- `allow()`
diff --git a/web/src/content/docs/reference/ImagePart.md b/web/src/content/docs/reference/ImagePart.md
new file mode 100644
index 00000000..5c740f50
--- /dev/null
+++ b/web/src/content/docs/reference/ImagePart.md
@@ -0,0 +1,48 @@
+---
+title: "ImagePart"
+description: "Documentation for the ImagePart type."
+slug: "reference/imagepart"
+---
+
+An image content part. The source may be a URL or base64-encoded data.
+
+## Class Diagram
+
+```mermaid
+---
+title: ImagePart
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ContentPart {
+        +string kind
+    }
+    ContentPart <|-- ImagePart
+    class ImagePart {
+        +string kind
+        +string source
+        +string detail
+        +string mediaType
+    }
+```
+
+## Yaml Example
+
+```yaml
+source: https://example.com/image.png
+detail: auto
+mediaType: image/png
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind identifier for image content |
+| source | string | URL or base64-encoded image data |
+| detail | string | Detail level hint for the model (e.g., 'auto', 'low', 'high') |
+| mediaType | string | MIME type of the image (e.g., 'image/png') |
diff --git a/web/src/content/docs/reference/McpApprovalMode.md b/web/src/content/docs/reference/McpApprovalMode.md
index 2855724d..aa10b0ff 100644
--- a/web/src/content/docs/reference/McpApprovalMode.md
+++ b/web/src/content/docs/reference/McpApprovalMode.md
@@ -5,8 +5,8 @@ slug: "reference/mcpapprovalmode"
 ---
 
 The approval mode for MCP server tools.
-When kind is &quot;specify&quot;, use alwaysRequireApprovalTools and neverRequireApprovalTools
-to control per-tool approval. For &quot;always&quot; and &quot;never&quot;, those fields are ignored.
+When kind is "specify", use alwaysRequireApprovalTools and neverRequireApprovalTools
+to control per-tool approval. For "always" and "never", those fields are ignored.
 
 ## Class Diagram
 
@@ -21,7 +21,6 @@ config:
 ---
 classDiagram
     class McpApprovalMode {
-      
         +string kind
         +string[] alwaysRequireApprovalTools
         +string[] neverRequireApprovalTools
@@ -42,9 +41,9 @@ neverRequireApprovalTools:
 
 | Name | Type | Description |
 | ---- | ---- | ----------- |
-| kind | string | The approval mode: &#39;always&#39;, &#39;never&#39;, or &#39;specify&#39; |
-| alwaysRequireApprovalTools | string[] | List of tools that always require approval (only used when kind is &#39;specify&#39;) |
-| neverRequireApprovalTools | string[] | List of tools that never require approval (only used when kind is &#39;specify&#39;) |
+| kind | string | The approval mode: 'always', 'never', or 'specify' |
+| alwaysRequireApprovalTools | string[] | List of tools that always require approval (only used when kind is 'specify') |
+| neverRequireApprovalTools | string[] | List of tools that never require approval (only used when kind is 'specify') |
 
 ## Alternate Constructions
 
diff --git a/web/src/content/docs/reference/McpTool.md b/web/src/content/docs/reference/McpTool.md
index 4c3939dd..cfb84479 100644
--- a/web/src/content/docs/reference/McpTool.md
+++ b/web/src/content/docs/reference/McpTool.md
@@ -26,7 +26,6 @@ classDiagram
     }
     Tool <|-- McpTool
     class McpTool {
-      
         +string kind
         +Connection connection
         +string serverName
diff --git a/web/src/content/docs/reference/Message.md b/web/src/content/docs/reference/Message.md
new file mode 100644
index 00000000..ab4a45b4
--- /dev/null
+++ b/web/src/content/docs/reference/Message.md
@@ -0,0 +1,73 @@
+---
+title: "Message"
+description: "Documentation for the Message type."
+slug: "reference/message"
+---
+
+A message in a conversation. Messages have a role and a list of content parts
+representing the different modalities of the message content.
+
+## Class Diagram
+
+```mermaid
+---
+title: Message
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class Message {
+        +string role
+        +ContentPart[] parts
+        +dictionary metadata
+    }
+    class ContentPart {
+        +string kind
+    }
+    Message *-- ContentPart
+```
+
+## Yaml Example
+
+```yaml
+role: user
+parts:
+  - kind: text
+    value: Hello!
+metadata:
+  source: user-input
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| role | string | The role of the message sender |
+| parts | [ContentPart[]](../contentpart/) | The content parts of the message(Related Types: [TextPart](../textpart/), [ImagePart](../imagepart/), [FilePart](../filepart/), [AudioPart](../audiopart/)) |
+| metadata | dictionary | Optional metadata associated with the message |
+
+## Helper Methods
+
+The following helper methods are declared via `@method` and must be implemented by every runtime. Idiomatic language shape (e.g. zero-param accessor may be a property) is chosen per-language by the emitter.
+
+| Name | Signature | Description |
+| ---- | --------- | ----------- |
+| `toTextContent` | `toTextContent() -> unknown` | Return plain string if all parts are text, else a list of content part dicts for wire serialization |
+| `text` | `text() -> string` | Concatenate all TextPart values joined by newline |
+
+## Factory Methods
+
+The following factory methods are declared via `@factory` and are generated automatically by the emitter in every language.
+
+- `assistant(text: string)`
+- `system(text: string)`
+- `user(text: string)`
+
+## Composed Types
+
+The following types are composed within `Message`:
+
+- [ContentPart](../contentpart/)
diff --git a/web/src/content/docs/reference/MessagesUpdatedPayload.md b/web/src/content/docs/reference/MessagesUpdatedPayload.md
new file mode 100644
index 00000000..d5db6b4c
--- /dev/null
+++ b/web/src/content/docs/reference/MessagesUpdatedPayload.md
@@ -0,0 +1,42 @@
+---
+title: "MessagesUpdatedPayload"
+description: "Documentation for the MessagesUpdatedPayload type."
+slug: "reference/messagesupdatedpayload"
+---
+
+Payload for "messages_updated" events — the conversation state has changed.
+
+## Class Diagram
+
+```mermaid
+---
+title: MessagesUpdatedPayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class MessagesUpdatedPayload {
+        +Message[] messages
+    }
+    class Message {
+        +string role
+        +ContentPart[] parts
+        +dictionary metadata
+    }
+    MessagesUpdatedPayload *-- Message
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| messages | [Message[]](../message/) | The current full message list after the update |
+
+## Composed Types
+
+The following types are composed within `MessagesUpdatedPayload`:
+
+- [Message](../message/)
diff --git a/web/src/content/docs/reference/Model.md b/web/src/content/docs/reference/Model.md
index de34d56e..2d12e404 100644
--- a/web/src/content/docs/reference/Model.md
+++ b/web/src/content/docs/reference/Model.md
@@ -5,7 +5,7 @@ slug: "reference/model"
 ---
 
 Model for defining the structure and behavior of AI agents.
-This model includes properties for specifying the model&#39;s provider, connection details, and various options.
+This model includes properties for specifying the model's provider, connection details, and various options.
 It allows for flexible configuration of AI models to suit different use cases and requirements.
 
 ## Class Diagram
@@ -21,7 +21,6 @@ config:
 ---
 classDiagram
     class Model {
-      
         +string id
         +string provider
         +string apiType
@@ -70,8 +69,8 @@ options:
 | Name | Type | Description |
 | ---- | ---- | ----------- |
 | id | string | The unique identifier of the model - can be used as the single property shorthand |
-| provider | string | The provider of the model (e.g., &#39;openai&#39;, &#39;foundry&#39;, &#39;anthropic&#39;) |
-| apiType | string | The type of API to use for the model (e.g., &#39;chat&#39;, &#39;response&#39;, etc.) |
+| provider | string | The provider of the model (e.g., 'openai', 'foundry', 'anthropic') |
+| apiType | string | The type of API to use for the model (e.g., 'chat', 'response', etc.) |
 | connection | [Connection](../connection/) | The connection configuration for the model(Related Types: [ReferenceConnection](../referenceconnection/), [RemoteConnection](../remoteconnection/), [ApiKeyConnection](../apikeyconnection/), [AnonymousConnection](../anonymousconnection/), [FoundryConnection](../foundryconnection/), [OAuthConnection](../oauthconnection/)) |
 | options | [ModelOptions](../modeloptions/) | Additional options for the model |
 
diff --git a/web/src/content/docs/reference/ModelInfo.md b/web/src/content/docs/reference/ModelInfo.md
new file mode 100644
index 00000000..e64c89c9
--- /dev/null
+++ b/web/src/content/docs/reference/ModelInfo.md
@@ -0,0 +1,63 @@
+---
+title: "ModelInfo"
+description: "Documentation for the ModelInfo type."
+slug: "reference/modelinfo"
+---
+
+Information about a model available from a provider. Used by provider-level
+model discovery to report which models are available and their capabilities.
+
+Not all providers return all fields — implementations SHOULD populate as
+many fields as the provider's API supports and MAY enrich sparse results
+from a built-in lookup table of known models.
+
+## Class Diagram
+
+```mermaid
+---
+title: ModelInfo
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ModelInfo {
+        +string id
+        +string displayName
+        +string ownedBy
+        +int32 contextWindow
+        +string[] inputModalities
+        +string[] outputModalities
+        +dictionary additionalProperties
+    }
+```
+
+## Yaml Example
+
+```yaml
+id: gpt-4o
+displayName: GPT-4o
+ownedBy: openai
+contextWindow: 128000
+inputModalities:
+  - text
+  - image
+outputModalities:
+  - text
+additionalProperties:
+  supportsStreaming: true
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| id | string | The model identifier (e.g., 'gpt-4o', 'claude-3-opus') |
+| displayName | string | Human-readable display name |
+| ownedBy | string | The organization or entity that owns the model |
+| contextWindow | int32 | Maximum context window size in tokens |
+| inputModalities | string[] | Input modalities the model accepts (e.g., 'text', 'image', 'audio') |
+| outputModalities | string[] | Output modalities the model can produce (e.g., 'text', 'audio') |
+| additionalProperties | dictionary | Additional provider-specific properties |
diff --git a/web/src/content/docs/reference/ModelOptions.md b/web/src/content/docs/reference/ModelOptions.md
index 1bbc55be..594f99ef 100644
--- a/web/src/content/docs/reference/ModelOptions.md
+++ b/web/src/content/docs/reference/ModelOptions.md
@@ -19,7 +19,6 @@ config:
 ---
 classDiagram
     class ModelOptions {
-      
         +float32 frequencyPenalty
         +int32 maxOutputTokens
         +float32 presencePenalty
@@ -57,9 +56,9 @@ additionalProperties:
 
 | Name | Type | Description |
 | ---- | ---- | ----------- |
-| frequencyPenalty | float32 | The frequency penalty to apply to the model&#39;s output |
+| frequencyPenalty | float32 | The frequency penalty to apply to the model's output |
 | maxOutputTokens | int32 | The maximum number of tokens to generate in the output |
-| presencePenalty | float32 | The presence penalty to apply to the model&#39;s output |
+| presencePenalty | float32 | The presence penalty to apply to the model's output |
 | seed | int32 | A random seed for deterministic output |
 | temperature | float32 | The temperature to use for sampling |
 | topK | int32 | The top-K sampling value |
diff --git a/web/src/content/docs/reference/OAuthConnection.md b/web/src/content/docs/reference/OAuthConnection.md
index 27e1817c..fce69abd 100644
--- a/web/src/content/docs/reference/OAuthConnection.md
+++ b/web/src/content/docs/reference/OAuthConnection.md
@@ -27,7 +27,6 @@ classDiagram
     }
     Connection <|-- OAuthConnection
     class OAuthConnection {
-      
         +string kind
         +string endpoint
         +string clientId
diff --git a/web/src/content/docs/reference/ObjectProperty.md b/web/src/content/docs/reference/ObjectProperty.md
index 0ff27fc0..6aeb43bb 100644
--- a/web/src/content/docs/reference/ObjectProperty.md
+++ b/web/src/content/docs/reference/ObjectProperty.md
@@ -30,7 +30,6 @@ classDiagram
     }
     Property <|-- ObjectProperty
     class ObjectProperty {
-      
         +string kind
         +Property[] properties
     }
diff --git a/web/src/content/docs/reference/OpenApiTool.md b/web/src/content/docs/reference/OpenApiTool.md
index 0c45e10e..779311eb 100644
--- a/web/src/content/docs/reference/OpenApiTool.md
+++ b/web/src/content/docs/reference/OpenApiTool.md
@@ -26,7 +26,6 @@ classDiagram
     }
     Tool <|-- OpenApiTool
     class OpenApiTool {
-      
         +string kind
         +Connection connection
         +string specification
diff --git a/web/src/content/docs/reference/Parser.md b/web/src/content/docs/reference/Parser.md
new file mode 100644
index 00000000..7a1a6710
--- /dev/null
+++ b/web/src/content/docs/reference/Parser.md
@@ -0,0 +1,32 @@
+---
+title: "Parser"
+description: "Documentation for the Parser type."
+slug: "reference/parser"
+---
+
+Parses rendered prompt text into an array of structured messages with role markers.
+
+## Class Diagram
+
+```mermaid
+---
+title: Parser
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class Parser {
+    }
+```
+
+## Helper Methods
+
+The following helper methods are declared via `@method` and must be implemented by every runtime. Idiomatic language shape (e.g. zero-param accessor may be a property) is chosen per-language by the emitter.
+
+| Name | Signature | Description |
+| ---- | --------- | ----------- |
+| `preRender` | `preRender(template: string) -> unknown?` _(optional, sync)_ | Pre-process a template before rendering, returning modified template and context |
+| `parse` | `parse(agent: Prompty, rendered: string, context: Record<unknown>?) -> Message[]` | Parse rendered text into a structured message array |
diff --git a/web/src/content/docs/reference/ParserConfig.md b/web/src/content/docs/reference/ParserConfig.md
index 1db68c0c..5e214a18 100644
--- a/web/src/content/docs/reference/ParserConfig.md
+++ b/web/src/content/docs/reference/ParserConfig.md
@@ -19,7 +19,6 @@ config:
 ---
 classDiagram
     class ParserConfig {
-      
         +string kind
         +dictionary options
     }
@@ -47,7 +46,7 @@ These allow for simplified creation of instances using a single property.
 
 ### string parser
 
-Simple construction with just a &quot;kind&quot; string
+Simple construction with just a "kind" string
 
 The following simplified representation can be used:
 
diff --git a/web/src/content/docs/reference/Processor.md b/web/src/content/docs/reference/Processor.md
new file mode 100644
index 00000000..2ba8ebf6
--- /dev/null
+++ b/web/src/content/docs/reference/Processor.md
@@ -0,0 +1,32 @@
+---
+title: "Processor"
+description: "Documentation for the Processor type."
+slug: "reference/processor"
+---
+
+Extracts a clean, typed result from a raw LLM provider response.
+
+## Class Diagram
+
+```mermaid
+---
+title: Processor
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class Processor {
+    }
+```
+
+## Helper Methods
+
+The following helper methods are declared via `@method` and must be implemented by every runtime. Idiomatic language shape (e.g. zero-param accessor may be a property) is chosen per-language by the emitter.
+
+| Name | Signature | Description |
+| ---- | --------- | ----------- |
+| `process` | `process(agent: Prompty, response: unknown) -> unknown` | Extract a clean result from a raw LLM response |
+| `processStream` | `processStream(stream: unknown) -> unknown` _(optional)_ | Process a streaming response into a stream of StreamChunk items. Takes raw chunks from the executor and yields processed text, thinking, tool, or error chunks. Not all providers support streaming; the default implementation should signal lack of support. |
diff --git a/web/src/content/docs/reference/Prompty.md b/web/src/content/docs/reference/Prompty.md
index bf0e39f4..a4357a1b 100644
--- a/web/src/content/docs/reference/Prompty.md
+++ b/web/src/content/docs/reference/Prompty.md
@@ -24,7 +24,6 @@ config:
 ---
 classDiagram
     class Prompty {
-      
         +string name
         +string displayName
         +string description
@@ -197,7 +196,7 @@ instructions: |-
 | ---- | ---- | ----------- |
 | name | string | Human-readable name of the prompt |
 | displayName | string | Display name for UI purposes |
-| description | string | Description of the prompt&#39;s purpose |
+| description | string | Description of the prompt's purpose |
 | metadata | dictionary | Additional metadata including authors, tags, and other arbitrary properties |
 | inputs | [Property[]](../property/) | Input parameters that participate in template rendering(Related Types: [ArrayProperty](../arrayproperty/), [ObjectProperty](../objectproperty/)) |
 | outputs | [Property[]](../property/) | Expected output format and structure |
diff --git a/web/src/content/docs/reference/PromptyTool.md b/web/src/content/docs/reference/PromptyTool.md
index 4732008e..447e01ee 100644
--- a/web/src/content/docs/reference/PromptyTool.md
+++ b/web/src/content/docs/reference/PromptyTool.md
@@ -29,7 +29,6 @@ classDiagram
     }
     Tool <|-- PromptyTool
     class PromptyTool {
-      
         +string kind
         +string path
         +string mode
@@ -50,4 +49,4 @@ mode: single
 | ---- | ---- | ----------- |
 | kind | string | The kind identifier for prompty tools |
 | path | string | Path to the child .prompty file, relative to the parent |
-| mode | string | Execution mode: &#39;single&#39; for one LLM call, &#39;agentic&#39; for full agent loop |
+| mode | string | Execution mode: 'single' for one LLM call, 'agentic' for full agent loop |
diff --git a/web/src/content/docs/reference/Property.md b/web/src/content/docs/reference/Property.md
index fd8016af..aff5c8c8 100644
--- a/web/src/content/docs/reference/Property.md
+++ b/web/src/content/docs/reference/Property.md
@@ -24,7 +24,6 @@ config:
 ---
 classDiagram
     class Property {
-      
         +string name
         +string kind
         +string description
diff --git a/web/src/content/docs/reference/ReferenceConnection.md b/web/src/content/docs/reference/ReferenceConnection.md
index 6954b377..b9ba89e4 100644
--- a/web/src/content/docs/reference/ReferenceConnection.md
+++ b/web/src/content/docs/reference/ReferenceConnection.md
@@ -25,7 +25,6 @@ classDiagram
     }
     Connection <|-- ReferenceConnection
     class ReferenceConnection {
-      
         +string kind
         +string name
         +string target
@@ -44,6 +43,6 @@ target: my-target-resource
 
 | Name | Type | Description |
 | ---- | ---- | ----------- |
-| kind | string | The Authentication kind for the AI service (e.g., &#39;key&#39; for API key, &#39;oauth&#39; for OAuth tokens) |
+| kind | string | The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens) |
 | name | string | The name of the connection |
 | target | string | The target resource or service that this connection refers to |
diff --git a/web/src/content/docs/reference/RemoteConnection.md b/web/src/content/docs/reference/RemoteConnection.md
index bc72c443..9dee446a 100644
--- a/web/src/content/docs/reference/RemoteConnection.md
+++ b/web/src/content/docs/reference/RemoteConnection.md
@@ -25,7 +25,6 @@ classDiagram
     }
     Connection <|-- RemoteConnection
     class RemoteConnection {
-      
         +string kind
         +string name
         +string endpoint
@@ -44,6 +43,6 @@ endpoint: https://{your-custom-endpoint}.openai.azure.com/
 
 | Name | Type | Description |
 | ---- | ---- | ----------- |
-| kind | string | The Authentication kind for the AI service (e.g., &#39;key&#39; for API key, &#39;oauth&#39; for OAuth tokens) |
+| kind | string | The Authentication kind for the AI service (e.g., 'key' for API key, 'oauth' for OAuth tokens) |
 | name | string | The name of the connection |
 | endpoint | string | The endpoint URL for the AI service |
diff --git a/web/src/content/docs/reference/Renderer.md b/web/src/content/docs/reference/Renderer.md
new file mode 100644
index 00000000..7bfab3be
--- /dev/null
+++ b/web/src/content/docs/reference/Renderer.md
@@ -0,0 +1,31 @@
+---
+title: "Renderer"
+description: "Documentation for the Renderer type."
+slug: "reference/renderer"
+---
+
+Renders a template string with input values to produce the final prompt text.
+
+## Class Diagram
+
+```mermaid
+---
+title: Renderer
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class Renderer {
+    }
+```
+
+## Helper Methods
+
+The following helper methods are declared via `@method` and must be implemented by every runtime. Idiomatic language shape (e.g. zero-param accessor may be a property) is chosen per-language by the emitter.
+
+| Name | Signature | Description |
+| ---- | --------- | ----------- |
+| `render` | `render(agent: Prompty, template: string, inputs: Record<unknown>) -> string` | Render the template string with input values |
diff --git a/web/src/content/docs/reference/StatusEventPayload.md b/web/src/content/docs/reference/StatusEventPayload.md
new file mode 100644
index 00000000..4d059c10
--- /dev/null
+++ b/web/src/content/docs/reference/StatusEventPayload.md
@@ -0,0 +1,36 @@
+---
+title: "StatusEventPayload"
+description: "Documentation for the StatusEventPayload type."
+slug: "reference/statuseventpayload"
+---
+
+Payload for "status" events — informational messages about loop progress.
+
+## Class Diagram
+
+```mermaid
+---
+title: StatusEventPayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class StatusEventPayload {
+        +string message
+    }
+```
+
+## Yaml Example
+
+```yaml
+message: Starting iteration 3
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| message | string | Human-readable status message |
diff --git a/web/src/content/docs/reference/StreamChunk.md b/web/src/content/docs/reference/StreamChunk.md
new file mode 100644
index 00000000..31f71f70
--- /dev/null
+++ b/web/src/content/docs/reference/StreamChunk.md
@@ -0,0 +1,61 @@
+---
+title: "StreamChunk"
+description: "Documentation for the StreamChunk type."
+slug: "reference/streamchunk"
+---
+
+A chunk of data from a streaming LLM response. Stream chunks are
+discriminated on the `kind` field.
+
+## Class Diagram
+
+```mermaid
+---
+title: StreamChunk
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class StreamChunk {
+      <<abstract>>
+        +string kind
+    }
+    class TextChunk {
+        +string kind
+        +string value
+    }
+    StreamChunk <|-- TextChunk
+    class ThinkingChunk {
+        +string kind
+        +string value
+    }
+    StreamChunk <|-- ThinkingChunk
+    class ToolChunk {
+        +string kind
+        +ToolCall toolCall
+    }
+    StreamChunk <|-- ToolChunk
+    class ErrorChunk {
+        +string kind
+        +string message
+    }
+    StreamChunk <|-- ErrorChunk
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind of stream chunk |
+
+## Child Types
+
+The following types extend `StreamChunk`:
+
+- [TextChunk](../textchunk/)
+- [ThinkingChunk](../thinkingchunk/)
+- [ToolChunk](../toolchunk/)
+- [ErrorChunk](../errorchunk/)
diff --git a/web/src/content/docs/reference/Template.md b/web/src/content/docs/reference/Template.md
index 06cbf26f..b3c3e50a 100644
--- a/web/src/content/docs/reference/Template.md
+++ b/web/src/content/docs/reference/Template.md
@@ -26,7 +26,6 @@ config:
 ---
 classDiagram
     class Template {
-      
         +FormatConfig format
         +ParserConfig parser
     }
diff --git a/web/src/content/docs/reference/TextChunk.md b/web/src/content/docs/reference/TextChunk.md
new file mode 100644
index 00000000..385d8506
--- /dev/null
+++ b/web/src/content/docs/reference/TextChunk.md
@@ -0,0 +1,42 @@
+---
+title: "TextChunk"
+description: "Documentation for the TextChunk type."
+slug: "reference/textchunk"
+---
+
+A text content chunk from the LLM response stream.
+
+## Class Diagram
+
+```mermaid
+---
+title: TextChunk
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class StreamChunk {
+        +string kind
+    }
+    StreamChunk <|-- TextChunk
+    class TextChunk {
+        +string kind
+        +string value
+    }
+```
+
+## Yaml Example
+
+```yaml
+value: Hello
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind identifier for text chunks |
+| value | string | The text content of the chunk |
diff --git a/web/src/content/docs/reference/TextPart.md b/web/src/content/docs/reference/TextPart.md
new file mode 100644
index 00000000..c9595dc3
--- /dev/null
+++ b/web/src/content/docs/reference/TextPart.md
@@ -0,0 +1,42 @@
+---
+title: "TextPart"
+description: "Documentation for the TextPart type."
+slug: "reference/textpart"
+---
+
+A text content part.
+
+## Class Diagram
+
+```mermaid
+---
+title: TextPart
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ContentPart {
+        +string kind
+    }
+    ContentPart <|-- TextPart
+    class TextPart {
+        +string kind
+        +string value
+    }
+```
+
+## Yaml Example
+
+```yaml
+value: Hello, world!
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind identifier for text content |
+| value | string | The text content |
diff --git a/web/src/content/docs/reference/ThinkingChunk.md b/web/src/content/docs/reference/ThinkingChunk.md
new file mode 100644
index 00000000..5d04cca0
--- /dev/null
+++ b/web/src/content/docs/reference/ThinkingChunk.md
@@ -0,0 +1,42 @@
+---
+title: "ThinkingChunk"
+description: "Documentation for the ThinkingChunk type."
+slug: "reference/thinkingchunk"
+---
+
+A thinking/reasoning content chunk from the LLM response stream.
+
+## Class Diagram
+
+```mermaid
+---
+title: ThinkingChunk
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class StreamChunk {
+        +string kind
+    }
+    StreamChunk <|-- ThinkingChunk
+    class ThinkingChunk {
+        +string kind
+        +string value
+    }
+```
+
+## Yaml Example
+
+```yaml
+value: Let me consider...
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind identifier for thinking chunks |
+| value | string | The thinking content of the chunk |
diff --git a/web/src/content/docs/reference/ThinkingEventPayload.md b/web/src/content/docs/reference/ThinkingEventPayload.md
new file mode 100644
index 00000000..1bfcfb6b
--- /dev/null
+++ b/web/src/content/docs/reference/ThinkingEventPayload.md
@@ -0,0 +1,36 @@
+---
+title: "ThinkingEventPayload"
+description: "Documentation for the ThinkingEventPayload type."
+slug: "reference/thinkingeventpayload"
+---
+
+Payload for "thinking" events — reasoning/chain-of-thought tokens.
+
+## Class Diagram
+
+```mermaid
+---
+title: ThinkingEventPayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ThinkingEventPayload {
+        +string token
+    }
+```
+
+## Yaml Example
+
+```yaml
+token: Let me consider...
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| token | string | The thinking/reasoning token text |
diff --git a/web/src/content/docs/reference/ThreadMarker.md b/web/src/content/docs/reference/ThreadMarker.md
new file mode 100644
index 00000000..0d329524
--- /dev/null
+++ b/web/src/content/docs/reference/ThreadMarker.md
@@ -0,0 +1,43 @@
+---
+title: "ThreadMarker"
+description: "Documentation for the ThreadMarker type."
+slug: "reference/threadmarker"
+---
+
+Positional marker for conversation history insertion during template rendering.
+
+During `prepare()`, nonce strings in rendered text are replaced with
+ThreadMarker objects. The pipeline then replaces them with actual
+conversation messages from the inputs.
+
+## Class Diagram
+
+```mermaid
+---
+title: ThreadMarker
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ThreadMarker {
+        +string name
+        +string kind
+    }
+```
+
+## Yaml Example
+
+```yaml
+name: thread
+kind: thread
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| name | string | The input property name (e.g. 'conversation') |
+| kind | string | The rich kind ('thread', 'image', 'file', 'audio') |
diff --git a/web/src/content/docs/reference/TokenEventPayload.md b/web/src/content/docs/reference/TokenEventPayload.md
new file mode 100644
index 00000000..e3d3a6a5
--- /dev/null
+++ b/web/src/content/docs/reference/TokenEventPayload.md
@@ -0,0 +1,36 @@
+---
+title: "TokenEventPayload"
+description: "Documentation for the TokenEventPayload type."
+slug: "reference/tokeneventpayload"
+---
+
+Payload for "token" events — a single text token streamed from the LLM.
+
+## Class Diagram
+
+```mermaid
+---
+title: TokenEventPayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class TokenEventPayload {
+        +string token
+    }
+```
+
+## Yaml Example
+
+```yaml
+token: Hello
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| token | string | The streamed token text |
diff --git a/web/src/content/docs/reference/TokenUsage.md b/web/src/content/docs/reference/TokenUsage.md
new file mode 100644
index 00000000..be3c7f1d
--- /dev/null
+++ b/web/src/content/docs/reference/TokenUsage.md
@@ -0,0 +1,44 @@
+---
+title: "TokenUsage"
+description: "Documentation for the TokenUsage type."
+slug: "reference/tokenusage"
+---
+
+Tracks token consumption for a single LLM call. Provider-specific field
+names (e.g., OpenAI's `prompt_tokens` vs Anthropic's `input_tokens`)
+are mapped via `knownAs` augments in the wire directory.
+
+## Class Diagram
+
+```mermaid
+---
+title: TokenUsage
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class TokenUsage {
+        +int32 promptTokens
+        +int32 completionTokens
+        +int32 totalTokens
+    }
+```
+
+## Yaml Example
+
+```yaml
+promptTokens: 150
+completionTokens: 42
+totalTokens: 192
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| promptTokens | int32 | Number of tokens in the prompt/input sent to the model |
+| completionTokens | int32 | Number of tokens generated in the model's completion/output |
+| totalTokens | int32 | Total tokens consumed (prompt + completion). May be provided by the API or computed. |
diff --git a/web/src/content/docs/reference/ToolCall.md b/web/src/content/docs/reference/ToolCall.md
new file mode 100644
index 00000000..7c6b8b2b
--- /dev/null
+++ b/web/src/content/docs/reference/ToolCall.md
@@ -0,0 +1,43 @@
+---
+title: "ToolCall"
+description: "Documentation for the ToolCall type."
+slug: "reference/toolcall"
+---
+
+A tool call requested by the LLM. Contains the function name and serialized
+arguments that should be dispatched to the appropriate tool handler.
+
+## Class Diagram
+
+```mermaid
+---
+title: ToolCall
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ToolCall {
+        +string id
+        +string name
+        +string arguments
+    }
+```
+
+## Yaml Example
+
+```yaml
+id: call_abc123
+name: get_weather
+arguments: '{"city": "Paris"}'
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| id | string | The unique identifier of the tool call |
+| name | string | The name of the tool to call |
+| arguments | string | The serialized JSON arguments for the tool call |
diff --git a/web/src/content/docs/reference/ToolCallStartPayload.md b/web/src/content/docs/reference/ToolCallStartPayload.md
new file mode 100644
index 00000000..f98a3e6f
--- /dev/null
+++ b/web/src/content/docs/reference/ToolCallStartPayload.md
@@ -0,0 +1,39 @@
+---
+title: "ToolCallStartPayload"
+description: "Documentation for the ToolCallStartPayload type."
+slug: "reference/toolcallstartpayload"
+---
+
+Payload for "tool_call_start" events — the LLM has requested a tool call.
+
+## Class Diagram
+
+```mermaid
+---
+title: ToolCallStartPayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ToolCallStartPayload {
+        +string name
+        +string arguments
+    }
+```
+
+## Yaml Example
+
+```yaml
+name: get_weather
+arguments: '{"city": "Paris"}'
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| name | string | The name of the tool being called |
+| arguments | string | The serialized JSON arguments for the tool call |
diff --git a/web/src/content/docs/reference/ToolChunk.md b/web/src/content/docs/reference/ToolChunk.md
new file mode 100644
index 00000000..0bc88518
--- /dev/null
+++ b/web/src/content/docs/reference/ToolChunk.md
@@ -0,0 +1,57 @@
+---
+title: "ToolChunk"
+description: "Documentation for the ToolChunk type."
+slug: "reference/toolchunk"
+---
+
+A tool call chunk from the LLM response stream.
+
+## Class Diagram
+
+```mermaid
+---
+title: ToolChunk
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class StreamChunk {
+        +string kind
+    }
+    StreamChunk <|-- ToolChunk
+    class ToolChunk {
+        +string kind
+        +ToolCall toolCall
+    }
+    class ToolCall {
+        +string id
+        +string name
+        +string arguments
+    }
+    ToolChunk *-- ToolCall
+```
+
+## Yaml Example
+
+```yaml
+toolCall:
+  id: call_abc123
+  name: get_weather
+  arguments: '{"city": "Paris"}'
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| kind | string | The kind identifier for tool chunks |
+| toolCall | [ToolCall](../toolcall/) | The tool call data |
+
+## Composed Types
+
+The following types are composed within `ToolChunk`:
+
+- [ToolCall](../toolcall/)
diff --git a/web/src/content/docs/reference/ToolContext.md b/web/src/content/docs/reference/ToolContext.md
new file mode 100644
index 00000000..b9f45ccc
--- /dev/null
+++ b/web/src/content/docs/reference/ToolContext.md
@@ -0,0 +1,53 @@
+---
+title: "ToolContext"
+description: "Documentation for the ToolContext type."
+slug: "reference/toolcontext"
+---
+
+Context passed to tool handlers during agent loop execution. Provides
+access to the agent configuration, current conversation state, and
+arbitrary metadata for tool implementations that need broader context.
+
+## Class Diagram
+
+```mermaid
+---
+title: ToolContext
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ToolContext {
+        +Message[] messages
+        +dictionary metadata
+    }
+    class Message {
+        +string role
+        +ContentPart[] parts
+        +dictionary metadata
+    }
+    ToolContext *-- Message
+```
+
+## Yaml Example
+
+```yaml
+metadata:
+  userId: user-123
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| messages | [Message[]](../message/) | The current conversation messages at the point of tool invocation |
+| metadata | dictionary | Optional metadata for tool-specific context (e.g., user session info) |
+
+## Composed Types
+
+The following types are composed within `ToolContext`:
+
+- [Message](../message/)
diff --git a/web/src/content/docs/reference/ToolDispatchResult.md b/web/src/content/docs/reference/ToolDispatchResult.md
new file mode 100644
index 00000000..224bea96
--- /dev/null
+++ b/web/src/content/docs/reference/ToolDispatchResult.md
@@ -0,0 +1,57 @@
+---
+title: "ToolDispatchResult"
+description: "Documentation for the ToolDispatchResult type."
+slug: "reference/tooldispatchresult"
+---
+
+The result of dispatching a single tool call. Pairs the tool call
+identifier with the tool's name and result for correlation in the
+agent loop's message assembly.
+
+## Class Diagram
+
+```mermaid
+---
+title: ToolDispatchResult
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ToolDispatchResult {
+        +string toolCallId
+        +string name
+        +ToolResult result
+    }
+    class ToolResult {
+        +ContentPart[] parts
+    }
+    ToolDispatchResult *-- ToolResult
+```
+
+## Yaml Example
+
+```yaml
+toolCallId: call_abc123
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| toolCallId | string | The tool call ID from the LLM response, used to correlate results |
+| name | string | The name of the tool that was called |
+| result | [ToolResult](../toolresult/) | The result produced by the tool handler |
+
+## Composed Types
+
+The following types are composed within `ToolDispatchResult`:
+
+- [ToolResult](../toolresult/)
diff --git a/web/src/content/docs/reference/ToolResult.md b/web/src/content/docs/reference/ToolResult.md
new file mode 100644
index 00000000..23c3339f
--- /dev/null
+++ b/web/src/content/docs/reference/ToolResult.md
@@ -0,0 +1,66 @@
+---
+title: "ToolResult"
+description: "Documentation for the ToolResult type."
+slug: "reference/toolresult"
+---
+
+The result of a tool execution. Contains a list of content parts, enabling
+rich tool results (text, images, files, audio) rather than just strings.
+
+Implementations MUST support conversion from a plain string to a ToolResult
+containing a single TextPart for backward compatibility.
+
+## Class Diagram
+
+```mermaid
+---
+title: ToolResult
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ToolResult {
+        +ContentPart[] parts
+    }
+    class ContentPart {
+        +string kind
+    }
+    ToolResult *-- ContentPart
+```
+
+## Yaml Example
+
+```yaml
+parts:
+  - kind: text
+    value: 72°F and sunny
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| parts | [ContentPart[]](../contentpart/) | The content parts of the tool result(Related Types: [TextPart](../textpart/), [ImagePart](../imagepart/), [FilePart](../filepart/), [AudioPart](../audiopart/)) |
+
+## Helper Methods
+
+The following helper methods are declared via `@method` and must be implemented by every runtime. Idiomatic language shape (e.g. zero-param accessor may be a property) is chosen per-language by the emitter.
+
+| Name | Signature | Description |
+| ---- | --------- | ----------- |
+| `text` | `text() -> string` | Concatenate all TextPart values joined by newline |
+
+## Factory Methods
+
+The following factory methods are declared via `@factory` and are generated automatically by the emitter in every language.
+
+- `text(value: string)`
+
+## Composed Types
+
+The following types are composed within `ToolResult`:
+
+- [ContentPart](../contentpart/)
diff --git a/web/src/content/docs/reference/ToolResultPayload.md b/web/src/content/docs/reference/ToolResultPayload.md
new file mode 100644
index 00000000..40045d60
--- /dev/null
+++ b/web/src/content/docs/reference/ToolResultPayload.md
@@ -0,0 +1,52 @@
+---
+title: "ToolResultPayload"
+description: "Documentation for the ToolResultPayload type."
+slug: "reference/toolresultpayload"
+---
+
+Payload for "tool_result" events — a tool has returned its result.
+
+## Class Diagram
+
+```mermaid
+---
+title: ToolResultPayload
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class ToolResultPayload {
+        +string name
+        +ToolResult result
+    }
+    class ToolResult {
+        +ContentPart[] parts
+    }
+    ToolResultPayload *-- ToolResult
+```
+
+## Yaml Example
+
+```yaml
+name: get_weather
+result:
+  parts:
+    - kind: text
+      value: 72°F and sunny
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| name | string | The name of the tool that produced the result |
+| result | [ToolResult](../toolresult/) | The tool's result |
+
+## Composed Types
+
+The following types are composed within `ToolResultPayload`:
+
+- [ToolResult](../toolresult/)
diff --git a/web/src/content/docs/reference/TurnOptions.md b/web/src/content/docs/reference/TurnOptions.md
new file mode 100644
index 00000000..2454df99
--- /dev/null
+++ b/web/src/content/docs/reference/TurnOptions.md
@@ -0,0 +1,72 @@
+---
+title: "TurnOptions"
+description: "Documentation for the TurnOptions type."
+slug: "reference/turnoptions"
+---
+
+Configuration for the agent loop's turn() function. Controls iteration
+limits, retry policy, context management, and execution behavior.
+
+Runtimes accept these as either a TurnOptions object or individual
+keyword/named parameters — the TypeSpec model defines the canonical
+field set.
+
+## Class Diagram
+
+```mermaid
+---
+title: TurnOptions
+config:
+  look: handDrawn
+  theme: colorful
+  class:
+    hideEmptyMembersBox: true
+---
+classDiagram
+    class TurnOptions {
+        +int32 maxIterations
+        +int32 maxLlmRetries
+        +int32 contextBudget
+        +boolean parallelToolCalls
+        +boolean raw
+        +int32 turn
+        +CompactionConfig compaction
+    }
+    class CompactionConfig {
+        +string strategy
+        +int32 budget
+        +dictionary options
+    }
+    TurnOptions *-- CompactionConfig
+```
+
+## Yaml Example
+
+```yaml
+maxIterations: 10
+maxLlmRetries: 3
+contextBudget: 100000
+parallelToolCalls: true
+raw: false
+turn: 1
+compaction:
+  strategy: summarize
+```
+
+## Properties
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| maxIterations | int32 | Maximum number of tool-call iterations before the loop terminates |
+| maxLlmRetries | int32 | Maximum number of LLM call retries on transient failure within a single iteration |
+| contextBudget | int32 | Character budget for the context window. When set, the loop trims older messages to stay within budget before each LLM call. System messages are never dropped. |
+| parallelToolCalls | boolean | Whether to execute multiple tool calls concurrently when the LLM returns several in one response |
+| raw | boolean | When true, return the raw LLM response without processor post-processing |
+| turn | int32 | Turn number for trace labeling. Useful when the caller maintains an outer conversation loop. |
+| compaction | [CompactionConfig](../compactionconfig/) | Context compaction configuration. Controls how messages are summarized when the context window exceeds the budget. |
+
+## Composed Types
+
+The following types are composed within `TurnOptions`:
+
+- [CompactionConfig](../compactionconfig/)
diff --git a/web/src/content/docs/reference/index.md b/web/src/content/docs/reference/index.md
index fa0f9eb9..1cc42830 100644
--- a/web/src/content/docs/reference/index.md
+++ b/web/src/content/docs/reference/index.md
@@ -1,6 +1,7 @@
 ---
 title: "AgentSchema"
 description: "Overview of declarative agent types in AgentSchema."
+slug: "reference/index"
 sidebar:
   order: 1
 ---
@@ -19,7 +20,6 @@ config:
 ---
 classDiagram
     class Property {
-      
         +string name
         +string kind
         +string description
@@ -29,12 +29,10 @@ classDiagram
         +unknown[] enumValues
     }
     class ObjectProperty {
-      
         +string kind
         +Property[] properties
     }
     class ArrayProperty {
-      
         +string kind
         +Property items
     }
@@ -45,37 +43,31 @@ classDiagram
         +string usageDescription
     }
     class ReferenceConnection {
-      
         +string kind
         +string name
         +string target
     }
     class RemoteConnection {
-      
         +string kind
         +string name
         +string endpoint
     }
     class ApiKeyConnection {
-      
         +string kind
         +string endpoint
         +string apiKey
     }
     class AnonymousConnection {
-      
         +string kind
         +string endpoint
     }
     class FoundryConnection {
-      
         +string kind
         +string endpoint
         +string name
         +string connectionType
     }
     class OAuthConnection {
-      
         +string kind
         +string endpoint
         +string clientId
@@ -84,7 +76,6 @@ classDiagram
         +string[] scopes
     }
     class ModelOptions {
-      
         +float32 frequencyPenalty
         +int32 maxOutputTokens
         +float32 presencePenalty
@@ -97,7 +88,6 @@ classDiagram
         +dictionary additionalProperties
     }
     class Model {
-      
         +string id
         +string provider
         +string apiType
@@ -105,7 +95,6 @@ classDiagram
         +ModelOptions options
     }
     class Binding {
-      
         +string name
         +string input
     }
@@ -117,25 +106,21 @@ classDiagram
         +Binding[] bindings
     }
     class FunctionTool {
-      
         +string kind
         +Property[] parameters
         +boolean strict
     }
     class CustomTool {
-      
         +string kind
         +Connection connection
         +dictionary options
     }
     class McpApprovalMode {
-      
         +string kind
         +string[] alwaysRequireApprovalTools
         +string[] neverRequireApprovalTools
     }
     class McpTool {
-      
         +string kind
         +Connection connection
         +string serverName
@@ -144,35 +129,29 @@ classDiagram
         +string[] allowedTools
     }
     class OpenApiTool {
-      
         +string kind
         +Connection connection
         +string specification
     }
     class PromptyTool {
-      
         +string kind
         +string path
         +string mode
     }
     class FormatConfig {
-      
         +string kind
         +boolean strict
         +dictionary options
     }
     class ParserConfig {
-      
         +string kind
         +dictionary options
     }
     class Template {
-      
         +FormatConfig format
         +ParserConfig parser
     }
     class Prompty {
-      
         +string name
         +string displayName
         +string description
@@ -184,6 +163,151 @@ classDiagram
         +Template template
         +string instructions
     }
+    class ContentPart {
+      <<abstract>>
+        +string kind
+    }
+    class TextPart {
+        +string kind
+        +string value
+    }
+    class ImagePart {
+        +string kind
+        +string source
+        +string detail
+        +string mediaType
+    }
+    class FilePart {
+        +string kind
+        +string source
+        +string mediaType
+    }
+    class AudioPart {
+        +string kind
+        +string source
+        +string mediaType
+    }
+    class Message {
+        +string role
+        +ContentPart[] parts
+        +dictionary metadata
+    }
+    class ToolContext {
+        +Message[] messages
+        +dictionary metadata
+    }
+    class ToolResult {
+        +ContentPart[] parts
+    }
+    class ToolDispatchResult {
+        +string toolCallId
+        +string name
+        +ToolResult result
+    }
+    class ToolCall {
+        +string id
+        +string name
+        +string arguments
+    }
+    class ThreadMarker {
+        +string name
+        +string kind
+    }
+    class GuardrailResult {
+        +boolean allowed
+        +string reason
+        +unknown rewrite
+    }
+    class TokenEventPayload {
+        +string token
+    }
+    class ThinkingEventPayload {
+        +string token
+    }
+    class ToolCallStartPayload {
+        +string name
+        +string arguments
+    }
+    class ToolResultPayload {
+        +string name
+        +ToolResult result
+    }
+    class StatusEventPayload {
+        +string message
+    }
+    class MessagesUpdatedPayload {
+        +Message[] messages
+    }
+    class DoneEventPayload {
+        +string response
+        +Message[] messages
+    }
+    class ErrorEventPayload {
+        +string message
+    }
+    class CompactionCompletePayload {
+        +int32 removed
+        +int32 remaining
+    }
+    class CompactionFailedPayload {
+        +string message
+    }
+    class StreamChunk {
+      <<abstract>>
+        +string kind
+    }
+    class TextChunk {
+        +string kind
+        +string value
+    }
+    class ThinkingChunk {
+        +string kind
+        +string value
+    }
+    class ToolChunk {
+        +string kind
+        +ToolCall toolCall
+    }
+    class ErrorChunk {
+        +string kind
+        +string message
+    }
+    class ModelInfo {
+        +string id
+        +string displayName
+        +string ownedBy
+        +int32 contextWindow
+        +string[] inputModalities
+        +string[] outputModalities
+        +dictionary additionalProperties
+    }
+    class CompactionConfig {
+        +string strategy
+        +int32 budget
+        +dictionary options
+    }
+    class TurnOptions {
+        +int32 maxIterations
+        +int32 maxLlmRetries
+        +int32 contextBudget
+        +boolean parallelToolCalls
+        +boolean raw
+        +int32 turn
+        +CompactionConfig compaction
+    }
+    class TokenUsage {
+        +int32 promptTokens
+        +int32 completionTokens
+        +int32 totalTokens
+    }
+    class Renderer {
+    }
+    class Parser {
+    }
+    class Executor {
+    }
+    class Processor {
+    }
     Property <|-- ArrayProperty
     Property <|-- ObjectProperty
     Connection <|-- ReferenceConnection
@@ -197,6 +321,14 @@ classDiagram
     Tool <|-- McpTool
     Tool <|-- OpenApiTool
     Tool <|-- PromptyTool
+    ContentPart <|-- TextPart
+    ContentPart <|-- ImagePart
+    ContentPart <|-- FilePart
+    ContentPart <|-- AudioPart
+    StreamChunk <|-- TextChunk
+    StreamChunk <|-- ThinkingChunk
+    StreamChunk <|-- ToolChunk
+    StreamChunk <|-- ErrorChunk
     ObjectProperty *-- Property
     ArrayProperty *-- Property
     Model *-- Connection
@@ -214,4 +346,13 @@ classDiagram
     Prompty *-- Model
     Prompty *-- Tool
     Prompty *-- Template
+    Message *-- ContentPart
+    ToolContext *-- Message
+    ToolResult *-- ContentPart
+    ToolDispatchResult *-- ToolResult
+    ToolResultPayload *-- ToolResult
+    MessagesUpdatedPayload *-- Message
+    DoneEventPayload *-- Message
+    ToolChunk *-- ToolCall
+    TurnOptions *-- CompactionConfig
 ```