Agents & Workflows¶

var xiansPlatform = await XiansPlatform.InitializeAsync(new XiansOptions
{
    ServerUrl = "https://your-server.com",
    ApiKey = "agent-certificate"
});

var agent = xiansPlatform.Agents.Register(new XiansAgentRegistration
{
    Name = "MyAgent",
    Version = "1.0.0",
    Description = "My intelligent agent",
    IsTemplate = true  // or false for tenant-specific
});

// Define an unnamed built-in workflow
var workflow = agent.Workflows.DefineBuiltIn();

// Define a named built-in workflow
var chatWorkflow = agent.Workflows.DefineBuiltIn(name: "ChatHandler");

// Register message handler
chatWorkflow.OnUserChatMessage(async (context) =>
{
    var userMessage = context.Message.Text;
    var response = await ProcessMessage(userMessage);
    await context.ReplyAsync(response);
});

// Register data message handler
chatWorkflow.OnUserDataMessage(async (context) =>
{
    var data = context.Message.Data;
    await ProcessData(data);
});

// Define custom workflow
var customWorkflow = agent.Workflows.DefineCustom<MyCustomWorkflow>();

// Add activities
customWorkflow.AddActivity<MyActivity>();
customWorkflow.AddActivity(new MyActivityInstance());

// Add multiple activities
customWorkflow.AddActivities(
    new Activity1(),
    new Activity2(),
    new Activity3()
);

using Temporalio.Workflows;

[Workflow]
public class MyCustomWorkflow
{
    [WorkflowRun]
    public async Task<string> RunAsync(WorkflowInput input)
    {
        // Execute activities
        var result = await Workflow.ExecuteActivityAsync(
            (MyActivity act) => act.ProcessAsync(input),
            new() { StartToCloseTimeout = TimeSpan.FromMinutes(5) }
        );

        // Wait for signals
        await Workflow.WaitConditionAsync(() => signalReceived);

        return result;
    }

    [WorkflowSignal]
    public async Task HandleSignalAsync(SignalData data)
    {
        // Handle signal
    }

    [WorkflowQuery]
    public string GetStatus() => currentStatus;
}

// In workflow or activity context
var agent = XiansContext.CurrentAgent;
var workflow = XiansContext.CurrentWorkflow;
var tenantId = XiansContext.TenantId;  // For system-scoped agents

chatWorkflow.OnUserChatMessage(async (context) =>
{
    // Access message data
    var message = context.Message.Text;
    var participantId = context.Message.ParticipantId;
    var requestId = context.Message.RequestId;
    var tenantId = context.Message.TenantId;
    var threadId = context.Message.ThreadId;
    var data = context.Message.Data;

    // Reply to user
    await context.ReplyAsync("Hello!");

    // Reply with text and data
    await context.ReplyAsync("Response text", new { key = "value" });

    // Send data message
    await context.SendDataAsync(new { key = "value" }, "Optional text");

    // Access agent's knowledge via XiansContext
    var agent = XiansContext.CurrentAgent;
    var knowledgeItem = await agent.Knowledge.GetAsync("knowledge-name");
    var allKnowledge = await agent.Knowledge.ListAsync();

    // Update knowledge
    await agent.Knowledge.UpdateAsync("knowledge-name", "content", type: "instruction");

    // Access documents
    var doc = await agent.Documents.GetAsync("doc-id");

    // Get chat history
    var history = await context.GetChatHistoryAsync(page: 1, pageSize: 10);
});

using Temporalio.Workflows;
using Xians.Lib.Agents.Core;
using Xians.Lib.Agents.Scheduling.Models;

[Workflow("MyAgent:RecurringTask")]
public class RecurringTaskWorkflow
{
    [WorkflowRun]
    public async Task RunAsync(string taskId, int intervalHours)
    {
        // At the start of the workflow, ensure a recurring schedule exists
        await EnsureScheduleExists(taskId, intervalHours);

        // Perform the actual work
        await DoWorkAsync(taskId);
    }

    private async Task EnsureScheduleExists(string taskId, int intervalHours)
    {
        try
        {
            // Self-schedule using XiansContext.CurrentWorkflow
            // Automatically uses activities when in workflow context!
            var schedule = await XiansContext.CurrentWorkflow.Schedules!
                .Create($"recurring-{taskId}")
                .WithIntervalSchedule(TimeSpan.FromHours(intervalHours))
                .WithInput(new object[] { taskId, intervalHours })
                .StartAsync();

            Workflow.Logger.LogInformation(
                "Schedule created - will run every {Hours} hours",
                intervalHours);
        }
        catch (ScheduleAlreadyExistsException ex)
        {
            Workflow.Logger.LogInformation(
                "Schedule already exists: {ScheduleId}",
                ex.ScheduleId);
        }
    }

    private async Task DoWorkAsync(string taskId)
    {
        // Your workflow logic here
        Workflow.Logger.LogInformation("Processing task: {TaskId}", taskId);
    }
}

[Workflow("MyAgent:ParentWorkflow")]
public class ParentWorkflow
{
    [WorkflowRun]
    public async Task RunAsync(string taskId)
    {
        // Start child workflow by type - fire and forget
        await XiansContext.Workflows.StartAsync<ChildWorkflow>(
            idPostfix: taskId,
            args: new object[] { "param1", "param2" }
        );

        // Continue without waiting for child to complete
        Workflow.Logger.LogInformation("Child workflow started");
    }
}

[Workflow("MyAgent:ParentWorkflow")]
public class ParentWorkflow
{
    [WorkflowRun]
    public async Task<string> RunAsync(string data)
    {
        // Execute child workflow and wait for result
        var result = await XiansContext.Workflows.ExecuteAsync<ChildWorkflow, string>(
            idPostfix: "process",
            args: new object[] { data }
        );

        return result;
    }
}