UAIX.UAI.Build 1.0.5

UAIX.UAI

UAIX.UAI is the official UAIX-owned .NET package family for UAI-1 message envelopes and lightweight AI memory support. It provides strongly typed message models, JSON serialization helpers, safe routing-discovery clients, thread-safe memory stores for agents and applications, and .uaix desktop AI memory package manifest generation, validation, import, export, activation preview, removal, bundle-switching helpers, and Advanced Persona / Personality Pack file contracts.

This workspace also includes UAIX.Talisman.AgentClient, a generic .NET connector for ecosystems that use the UAIX Talisman strategy. It is not site-specific: callers configure ecosystem keys, node keys, client base URLs, hub base URLs, and Talisman hub routes for their own runtime.

UAIX.Talisman.EcosystemManager is the matching ASP.NET Core hub package. It exposes AgentClient-compatible status, sync, no-op talk-back, evidence packet, effective-policy, client-agent message, instruction, acknowledgement, and .uai bundle-ingest endpoints with review-only protected-anchor governance. It also mirrors feasible WordPress manager review/data routes for change requests, proposals, audit records, OpenAPI discovery, LocalEndpoint, ErrorNotifier, Carcinus, and CreativeExpansion client intake.

UAIX.AdaptiveInteroperability is the separate adaptive AI-to-AI interoperability package. Use it for capability profiles, fallback-chain resolution, ASP.NET Core route metadata, typed HttpClient discovery, UAI-1 evidence export, optional MCP/A2A adapter integration, and conformance tests. It is not a Talisman governance package and does not certify remote trust.

UAIX.LmRuntime is the pre-publication pure-managed .NET 9 local LLM runtime package family for LocalEndpoint-style GGUF/LLaMA execution. It lives at UAIX.LmRuntime/, uses UAIX.LmRuntime.* package IDs and namespaces, and currently packs UAIX.LmRuntime.Abstractions, UAIX.LmRuntime.Tensors, UAIX.LmRuntime.Gguf, UAIX.LmRuntime.Tokenization, UAIX.LmRuntime.Sampling, UAIX.LmRuntime.Kernels.Cpu, UAIX.LmRuntime.Models.Llama, and UAIX.LmRuntime.LocalEndpoint.

Install

dotnet add package UAIX.UAI --version 1.0.5
dotnet add package UAIX.UAI.Memory --version 1.0.5
dotnet add package UAIX.UAI.Abstractions --version 1.0.5
dotnet add package UAIX.Talisman.AgentClient --version 0.1.10
dotnet add package UAIX.Talisman.EcosystemManager --version 0.1.1
dotnet add package UAIX.AdaptiveInteroperability --version 0.2.0

Use UAIX.UAI for the main UAI-1 message, routing, HTTP, .uaix, Advanced Persona profile validation/export, and runtime handoff surface. Use UAIX.UAI.Memory when an app only needs local AI memory stores for project handoff, persona notes, preferences, release notes, and operational context. Use UAIX.UAI.Abstractions for shared interfaces and models in libraries that should avoid the heavier runtime dependency.

UAIX.UAI.Build is an MSBuild support package. Most applications do not need to reference it directly.

UAIX.Talisman.AgentClient is a separate package for ecosystems that use the UAIX Talisman strategy. UAIX.Talisman.EcosystemManager is the .NET hub package that AgentClient can connect to when a WordPress manager is not the runtime host.

UAIX.AdaptiveInteroperability is intentionally separate from both Talisman packages. It should decide how two agents can communicate based on evidence of capability, not philosophical alignment, protected-anchor policy, or package-memory ownership. The current source line models UAIX.org's capability-adaptive L0-L7 levels, exact route-record fallback fields, pre-network decision request validation, and UAI-1 evidence for route-backed decisions.

UAIX.LmRuntime is intentionally separate from .uaix import, expanded .uai profile loading, prompt assembly, policy, registry, audit, JSONL, telemetry, providers, commands, and LocalEndpoint production adoption. It receives already assembled prompt/context metadata and owns only local managed GGUF verification, mapping, tokenization, and deterministic inference surfaces.

Resolve Adaptive AI-to-AI Interoperability

using UAIX.AdaptiveInteroperability;

AdaptiveCapabilityProfile profile = AdaptiveInteropValidatorFixtures.PublicFallbackOnlyAgent();
AdaptiveInteropRequest request = new()
{
    Operation = "carcinus_profile_restore",
    RequiresAuthentication = true,
    RequiresReadback = true
};

AdaptiveInteropDecision decision = new FallbackChainResolver().Resolve(profile, request);
string evidenceJson = AdaptiveInteropEvidenceExporter.ExportJson(profile, request, decision);

The resolver chooses the highest safe proven path and always keeps No-Op/human review at the end of the fallback chain. MCP, A2A, JSON POST, authentication, readback, and tool support must be proven before the resolver ramps up to those paths. Missing or unsafe capability falls back through route-record fields such as lowest_safe_fallback, post_blocked_fallback, live_get_blocked_fallback, mcp_unavailable_fallback, auth_unavailable_fallback, tool_unavailable_fallback, human_review_url, and no_op_behavior.

For prepublish-safe automation, remote profile resolution fails closed when a fetched capability profile is invalid, and requests can set MinimumCapabilityLevel to prevent lower-capability fallbacks from being used for operations that require schema-capable, authenticated, restore/readback, multi-agent, or site-specific negotiation support.

Use Talisman Protected-Anchor Checks

using UAIX.Talisman.AgentClient;

TalismanClientOptions options = TalismanClientOptions.FromEnvironment() with
{
    EcosystemKey = "my-ecosystem",
    NodeKey = "my-agent-node",
    ClientBaseUrl = "https://example.org"
};

TalismanAgentClient agent = new(options, enableHubClient: false);

GateDecision decision = agent.PrecheckToolCall(
    "delete_file",
    new Dictionary<string, object?> { ["path"] = ".uai/totem.uai" });

UAIX.Talisman.AgentClient treats .uai/totem.uai, .uai/taboo.uai, and .uai/talisman.uai as protected data. It records no-op evidence and request-only talk-back records; it does not approve changes, mutate protected anchors, validate credentials, certify runtime safety, or replace human review.

Host A Talisman Ecosystem Manager

using UAIX.Talisman.EcosystemManager;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

builder.Services.AddUaixTalismanEcosystemManager(options =>
{
    options.DataDirectory = Path.Combine(AppContext.BaseDirectory, "uaix-talisman-data");
    options.AgentKeys.Add("replace-with-scoped-token");
});

WebApplication app = builder.Build();
app.MapUaixTalismanEcosystemManager();
app.Run();

The default route prefix is /wp-json/uaix-talisman/v1 so AgentClient can use the same route names as the WordPress ecosystem manager:

TalismanAgentClient agent = new(new TalismanClientOptions
{
    HubBaseUrl = "https://localhost:5001/wp-json/uaix-talisman/v1",
    AgentKey = "replace-with-scoped-token",
    EcosystemKey = "teleodynamic_default",
    NodeKey = "localendpoint-desktop-agent",
    AnchorDirectory = ".uai"
});

await agent.SyncAnchorsAsync();

The .NET manager stores .uai anchors and .uai bundle packets as data/review evidence. A successful API response does not approve, apply, publish, roll back, certify, or mutate protected anchors.

For LocalEndpoint-style dogfooding, use UAIX.UAI for .uaix bundle import/export/activation and running-instance UAI messages, use UAIX.Talisman.AgentClient inside the agent/runtime, and host UAIX.Talisman.EcosystemManager as the local or service hub when WordPress is not the hub.

Create a UAI-1 Message

using System.Text.Json;
using UAIX.UAI.Core;

var body = JsonSerializer.SerializeToElement(new
{
    text = "Summarize the last support conversation.",
    intent = "summarize"
});

var message = UaiMessage.Create(
    profile: "agent.request",
    source: new Participant("agent", "support-copilot"),
    target: new Participant("service", "summary-api"),
    body: body);

var serializer = new UaiJsonSerializer();
var json = serializer.Serialize(message);
var roundTripped = serializer.Deserialize<UaiMessage>(json);

if (!roundTripped.IsValid)
{
    throw new InvalidOperationException(string.Join(Environment.NewLine, roundTripped.Validate()));
}

Use AI Memory

using UAIX.UAI.Memory;

var memory = new FileAgentMemory("agent-memory.json");

await memory.AddAsync("Customer prefers email updates.", category: "preference");
await memory.AddAsync("Open incident EN-1024 is waiting on billing details.", category: "case");

var matches = await memory.QueryAsync("billing");

InMemoryAgentMemory is useful for tests and short-lived processes. FileAgentMemory persists entries as JSON and uses asynchronous, thread-safe access. Both stores return defensive copies so callers cannot mutate the saved memory state accidentally.

Routing Discovery

UaixRoutingConfigClient fetches UAIX routing configuration from a configurable endpoint. The SDK does not make operating-system routing or network-stack changes; it exposes safe placeholders for future integrations that applications may opt into deliberately.

using UAIX.UAI.Core;

var client = new UaixRoutingConfigClient(httpClient);
var config = await client.FetchAsync(new Uri("https://uaix.org/.well-known/uai.json"));
var validateRoute = config.ResolveRoute("validate");

The routing client understands both compact UAIX .well-known route maps and explicit route arrays. Fetched configurations are validated for absolute HTTP/HTTPS endpoints before they are returned.

Send A Typed Message

using UAIX.UAI.Core;

var uai = new HttpUaiClient(httpClient);
var response = await uai.SendAsync(
    new Uri("https://uaix.org/wp-json/uaix/v1/validate"),
    message);

The typed send helper validates the UaiMessage locally before posting JSON. The lower-level string send method is still available when an application already owns serialization.

Validate And Switch .uaix Bundles

.uaix files are ZIP containers with a .uai/manifest.uaix.json manifest. UAIX.UAI can generate that manifest when exporting a normal folder, validates the newer manifest files array shape before extraction, and rejects unsafe entries such as path traversal, absolute paths, drive-root paths, device names, duplicate normalized paths, symlinks, manifest/file mismatches, and hash mismatches.

Generated manifests write the current UAIX draft shape: packageFormat is .uaix, profileId is uaix.package.v0.1, status is draft_v0.1, issuer and file source are structured objects, entrypoints.requiredReads is an array, each file scope is an array, integrity.fileCount is emitted, and supportBoundary is a string. The reader remains tolerant of older local manifests that used string scopes, string issuers/sources, dictionary support boundaries, and legacy persona / profile / project scopes.

For persona packages, current generated manifests use the public UAIX scopes persona_profile and advanced_persona_profile. When advanced_persona_profile is declared, validation requires .uai/persona.uai, every required .uai/personality/*.uai profile file, the required .uai/evidence/*.uai fidelity/provenance files, and matching entrypoints.requiredReads records. The identity-dimension files are separate required files: .uai/personality/religion-worldview.uai, .uai/personality/political-leaning.uai, .uai/personality/sense-of-style.uai, .uai/personality/physical-appearance.uai, .uai/personality/birth-age-generation.uai, and .uai/personality/romantic-orientation.uai.

using UAIX.UAI.Core;

var exportResult = await new UaixPackageExporter().ExportDirectoryAsync(
    sourceDirectory: "profile-folder",
    destinationPackagePath: "profile.uaix",
    new UaixPackageExportOptions
    {
        PackageId = "creative-profile",
        ProfileId = "creative-profile",
        Issuer = "MyDesktopApp"
    });

if (!exportResult.IsValid)
{
    throw new InvalidOperationException(string.Join(Environment.NewLine, exportResult.Errors.Select(issue => issue.Message)));
}

var validator = new UaixPackageValidator();
var result = await validator.ValidatePackageAsync("profile.uaix");

if (!result.IsValid)
{
    throw new InvalidOperationException(string.Join(Environment.NewLine, result.Errors.Select(issue => issue.Message)));
}

var store = new UaixBundleStore("uaix-bundles");
var bundle = await store.ImportAsync("profile.uaix");
var preview = await store.PreviewActivationAsync(bundle.PackageId);

foreach (var line in preview.Summary)
{
    Console.WriteLine(line);
}

await store.ActivateAsync(bundle.PackageId);

Package validation and bundle activation do not mutate running AI instances. Running-instance communication should still use explicit UAI-1 message endpoints such as HttpUaiClient.

When a source folder does not already contain .uai/manifest.uaix.json, UaixPackageExporter generates the manifest, file hashes, declared scopes, entrypoints, support boundary, and manifest sentinel in the archive without mutating the source folder. Set RegenerateManifest = true when a source folder has a stale manifest that should be replaced during export.

Imports validate into a staging directory, then replace the target bundle content directory rather than merging into stale files. Exports must write the .uaix file outside the source directory so a package cannot accidentally include itself.

Desktop bundle managers should call PreviewActivationAsync(packageId) before switching profiles. The preview reports the current bundle, candidate bundle, scope changes, entrypoint changes, and support-boundary changes without changing active state. Use RemoveAsync(packageId) to uninstall a local bundle; if the removed bundle was active, the active-bundle pointer is cleared instead of left stale.

LocalEndpoint-Style Runtime Handoff

A desktop app can keep package storage and live instance communication separate. Import and activate the bundle locally, then attach the active bundle as declared context only when an explicit runtime send occurs:

using System.Text.Json;
using UAIX.UAI.Core;

var store = new UaixBundleStore("uaix-bundles");
var installed = await store.ImportAsync("creative-profile.uaix");
await store.ActivateAsync(installed.PackageId);

var activeBundle = await store.GetActiveAsync();
var bundleContext = activeBundle == null
    ? null
    : UaiRuntimeBundleContext.FromBundle(activeBundle);

var peer = new UaiRuntimePeer(
    new Participant("agent", "localendpoint-desktop"),
    new Uri("https://localhost:7443/uai"));

var message = UaiMessage.Create(
    "agent.request",
    new Participant("agent", "desktop-shell"),
    peer.Participant,
    JsonSerializer.SerializeToElement(new
    {
        task = "continue_with_active_bundle"
    }));

var channel = new UaiRuntimeChannel(new HttpUaiClient(httpClient));
var response = await channel.SendAsync(peer, message, bundleContext);

UaiRuntimeChannel copies the message before adding the uaix_active_bundle extension, so caller-owned messages remain unchanged. UaixBundleStore.ActivateAsync only changes local active-bundle state; it does not send, approve, apply, or synchronize runtime messages.

Placement decision: .uaix package support stays in UAIX.UAI.Core for the current package line so desktop apps can use package state and UAI messaging from one SDK. Split it into a dedicated package later only if the desktop integration surface grows enough to justify the extra dependency boundary.

Build

dotnet restore
dotnet build -c Release
dotnet pack -c Release

Packages are emitted to the UAIX publish pickup folder:

E:\Source\WP\UAIX-Publish\DOTNET-NUGET

Expected package files:

• UAIX.UAI.1.0.5.nupkg
• UAIX.UAI.Memory.1.0.5.nupkg
• UAIX.UAI.Abstractions.1.0.5.nupkg
• UAIX.UAI.Build.1.0.5.nupkg
• UAIX.Talisman.AgentClient.0.1.10.nupkg
• UAIX.Talisman.EcosystemManager.0.1.1.nupkg
• UAIX.AdaptiveInteroperability.0.2.0.nupkg
• UAIX.LmRuntime.Abstractions.3.3.18.nupkg
• UAIX.LmRuntime.Tensors.3.3.18.nupkg
• UAIX.LmRuntime.Gguf.3.3.18.nupkg
• UAIX.LmRuntime.Tokenization.3.3.18.nupkg
• UAIX.LmRuntime.Sampling.3.3.18.nupkg
• UAIX.LmRuntime.Kernels.Cpu.3.3.18.nupkg
• UAIX.LmRuntime.Models.Llama.3.3.18.nupkg
• UAIX.LmRuntime.LocalEndpoint.3.3.18.nupkg

Symbol packages are emitted as .snupkg files.