C# .NET SDK - API Reference

using Corti;

// List interactions (pager — see Pagination)
var pager = await client.Interactions.ListAsync(new InteractionsListRequest());

// Create a new interaction
var response = await client.Interactions.CreateAsync(
    new InteractionsCreateRequest
    {
        Encounter = new InteractionsEncounterCreateRequest
        {
            Identifier = "my-encounter-id",
            Status = InteractionsEncounterStatusEnum.Planned,
            Type = InteractionsEncounterTypeEnum.FirstConsultation,
        },
    });

var interactionId = response.InteractionId;

// Get a specific interaction
var interaction = await client.Interactions.GetAsync(interactionId);

// Update an interaction
await client.Interactions.UpdateAsync(
    interactionId,
    new InteractionsUpdateRequest
    {
        Encounter = new InteractionsEncounterUpdateRequest
        {
            Status = InteractionsEncounterStatusEnum.InProgress,
        },
    });

// Delete an interaction
await client.Interactions.DeleteAsync(interactionId);

using Corti;

// Upload a recording
var recording = await client.Recordings.UploadAsync(
    interactionId,
    File.OpenRead("audio.mp3"));

var recordingId = recording.RecordingId;

// List recordings for an interaction
var recordings = await client.Recordings.ListAsync(interactionId);

// Download a recording
var stream = await client.Recordings.GetAsync(interactionId, recordingId);

// Delete a recording
await client.Recordings.DeleteAsync(interactionId, recordingId);

using Corti;

// Create a transcript from a recording
var transcript = await client.Transcripts.CreateAsync(
    interactionId,
    new TranscriptsCreateRequest
    {
        RecordingId = recordingId,
        PrimaryLanguage = "en",
    });

var transcriptId = transcript.Id;

// Check transcription status
var status = await client.Transcripts.GetStatusAsync(interactionId, transcriptId);

// List transcripts for an interaction
var transcripts = await client.Transcripts.ListAsync(interactionId);

// Get a specific transcript
var result = await client.Transcripts.GetAsync(interactionId, transcriptId);

// Delete a transcript
await client.Transcripts.DeleteAsync(interactionId, transcriptId);

using Corti;

// Generate a document
var document = await client.Documents.CreateAsync(
    interactionId,
    new DocumentsCreateRequestWithTemplateKey
    {
        TemplateKey = "corti-soap",
        OutputLanguage = "en",
        Context = new[]
        {
            new DocumentsContextWithFacts
            {
                Type = DocumentsContextWithFactsType.Facts,
                Data = new[]
                {
                    new FactsContext { Text = "Patient reports persistent headache for 3 days", Source = CommonSourceEnum.Core },
                    new FactsContext { Text = "No history of migraines", Source = CommonSourceEnum.User },
                },
            },
        },
    });

var documentId = document.Id;

// List documents
var documents = await client.Documents.ListAsync(interactionId);

// Get a specific document
var doc = await client.Documents.GetAsync(interactionId, documentId);

// Update a document
await client.Documents.UpdateAsync(
    interactionId,
    documentId,
    new DocumentsUpdateRequest { Name = "Updated note" });

// Delete a document
await client.Documents.DeleteAsync(interactionId, documentId);

using Corti;

// Extract facts from text (standalone)
var extracted = await client.Facts.ExtractAsync(
    new FactsExtractRequest
    {
        Context = new[]
        {
            new CommonTextContext
            {
                Type = CommonTextContextType.Text,
                Text = "Patient has a temperature of 38.5°C and reports headache.",
            },
        },
        OutputLanguage = "en",
    });

// List facts for an interaction
var facts = await client.Facts.ListAsync(interactionId);

// Create facts on an interaction
var created = await client.Facts.CreateAsync(
    interactionId,
    new FactsCreateRequest
    {
        Facts = new[]
        {
            new FactsCreateInput { Text = "Temperature 38.5°C", Group = "vitals" },
        },
    });

// Update a single fact
await client.Facts.UpdateAsync(
    interactionId,
    factId,
    new FactsUpdateRequest { Text = "Temperature 39.0°C" });

// List available fact groups
var groups = await client.Facts.FactGroupsListAsync();

using Corti;

// List agents
var agents = await client.Agents.ListAsync(new AgentsListRequest());

// Create an agent
var agent = await client.Agents.CreateAsync(
    new AgentsCreateAgent
    {
        Name = "My Agent",
        Description = "A helpful assistant",
    });

// Get agent details
var details = await client.Agents.GetAsync(agent.Id);

// Send a message to an agent
var response = await client.Agents.MessageSendAsync(
    agent.Id,
    new AgentsMessageSendParams
    {
        Message = new AgentsMessage
        {
            Role = AgentsMessageRole.User,
            Kind = AgentsMessageKind.Message,
            MessageId = $"msg-{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}",
            Parts = new[]
            {
                AgentsPart.FromAgentsTextPart(
                    new AgentsTextPart { Kind = AgentsTextPartKind.Text, Text = "Hello" }),
            },
        },
    });

// Update an agent
await client.Agents.UpdateAsync(agent.Id, new AgentsUpdateAgent { Description = "Updated" });

// Delete an agent
await client.Agents.DeleteAsync(agent.Id);

var stream = await client.CreateStreamApiAsync(interactionId);

stream.StreamTranscriptMessage.Subscribe(message =>
{
    Console.WriteLine($"Transcript: {message.Data.Text}");
});

stream.StreamFactsMessage.Subscribe(_ =>
{
    Console.WriteLine("Facts received");
});

await stream.ConnectAsync(new StreamConfig
{
    Transcription = new StreamConfigTranscription
    {
        PrimaryLanguage = "en",
        Participants = new[]
        {
            new StreamConfigParticipant { Channel = 0, Role = StreamConfigParticipantRole.Doctor },
        },
    },
    Mode = new StreamConfigMode
    {
        Type = StreamConfigModeType.Facts,
        OutputLocale = "en",
    },
});

await stream.Send(audioBytes);