C# .NET SDK - API Reference

using System.Collections.Generic;
using Corti;

await client.Interactions.ListAsync(
    new InteractionsListRequest(),
    new RequestOptions
    {
        Timeout = TimeSpan.FromSeconds(30),
        MaxRetries = 3,
        AdditionalHeaders = new Dictionary<string, string?>
        {
            ["X-Request-Id"] = "abc123",
        },
    });

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;

// --- Templates ---

// List templates (with optional filters)
var templates = await client.Documents.Templates.ListAsync(
    new GuidedTemplatesListRequest { Lang = new[] { "en" }, Published = true });

// Create a template from scratch
var template = await client.Documents.Templates.CreateAsync(
    new GuidedTemplatesCreateFromScratchRequest
    {
        Name = "My Template",
        Description = "Custom SOAP note",
        Lang = "en",
        Sections = new[] { new GuidedTemplateSectionRef { SectionId = "<section-uuid>", Order = 0 } },
    });

// Get / update / delete a template
var tmpl = await client.Documents.Templates.GetAsync(templateId);
await client.Documents.Templates.UpdateAsync(templateId,
    new GuidedTemplatesUpdateRequest { Name = "Renamed" });
await client.Documents.Templates.DeleteAsync(templateId);

// --- Template Versions ---

var versions = await client.Documents.Templates.Versions.ListAsync(templateId);
var version = await client.Documents.Templates.Versions.CreateAsync(templateId,
    new GuidedTemplatesCreateVersionRequest
    {
        Sections = new[] { new GuidedTemplateSectionRef { SectionId = "<section-uuid>", Order = 0 } },
    });
await client.Documents.Templates.Versions.PublishAsync(templateId, versionId);
await client.Documents.Templates.Versions.DeleteAsync(templateId, versionId);

// --- Sections ---

var sections = await client.Documents.Sections.ListAsync(
    new GuidedSectionsListRequest { Lang = new[] { "en" } });
var section = await client.Documents.Sections.CreateAsync(
    new GuidedSectionsCreateFromScratchRequest
    {
        Name = "HPI",
        Generation = new GuidedSectionGeneration
        {
            Heading = "History of Present Illness",
            Instructions = new GuidedSectionInstructions { ContentPrompt = "Summarize the patient history" },
            OutputSchema = new GuidedStringNode(),
        },
    });
await client.Documents.Sections.UpdateAsync(sectionId,
    new GuidedSectionsUpdateRequest { Name = "Renamed" });
await client.Documents.Sections.DeleteAsync(sectionId);

// --- Section Versions ---

var sectionVersions = await client.Documents.Sections.Versions.ListAsync(sectionId);
await client.Documents.Sections.Versions.PublishAsync(sectionId, versionId);

// --- Generate ---

var result = await client.Documents.GenerateAsync(
    new GuidedDocumentsGenerateByTemplateRef
    {
        OutputLanguage = "en-US",
        InteractionId = "<interaction-uuid>",
        TemplateRef = new GuidedTemplateRef { TemplateId = "<template-uuid>" },
    });

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 = new CommonTextContext.TypeLiteral(),
                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 all templates
var templates = await client.Templates.ListAsync(new TemplatesListRequest());

// Get a specific template by key
var template = await client.Templates.GetAsync("corti-soap");

// List template sections
var sections = await client.Templates.SectionListAsync(new TemplatesSectionListRequest());

var response = await client.Codes.PredictAsync(new CodesGeneralPredictRequest
{
    System = [CommonCodingSystemEnum.Icd10CmInpatient],
    Context =
    [
        new CommonTextContext
        {
            Type = new CommonTextContext.TypeLiteral(),
            Text = "Progress Note — Day 3: Patient continues on IV vancomycin for MRSA bacteremia. Blood cultures from yesterday still pending. Acute kidney injury improving — creatinine down to 1.8 from 2.4. Patient also has history of CHF, currently euvolemic on home dose of furosemide. Diabetes managed with insulin sliding scale, glucose well controlled.",
        },
    ],
});

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);

var transcribe = await client.CreateTranscribeApiAsync();

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

await transcribe.ConnectAsync(new TranscribeConfig
{
    PrimaryLanguage = "en",
    AutomaticPunctuation = true,
});

// Send audio data (e.g. from a microphone stream)
await transcribe.Send(audioBytes);

using Corti;

// Replace these with your values
const string CLIENT_ID = "<your-client-id>";
const string CLIENT_SECRET = "<your-client-secret>";
const string ENVIRONMENT = "<eu-or-us>";
const string TENANT = "<your-tenant-name>";

var auth = CustomAuthClient.Create(
    new CortiAuthClientOptions
    {
        TenantName = TENANT,
        Environment = ENVIRONMENT,
    });

var tokenResponse = await auth.GetTokenAsync(
    new OAuthTokenRequest
    {
        ClientId = CLIENT_ID,
        ClientSecret = CLIENT_SECRET,
    });

Console.WriteLine(tokenResponse.AccessToken);

using Corti;

try
{
    await client.Interactions.GetAsync("non-existent-id");
}
catch (CortiClientApiException ex)
{
    Console.WriteLine($"Status: {ex.StatusCode}");
    Console.WriteLine($"Message: {ex.Message}");
    Console.WriteLine($"Body: {ex.Body}");
}

using Corti;

// Built-in region
// var env = CortiEnvironments.FromRegion("eu");

// Custom proxy base URL
var env = CortiEnvironments.FromBaseUrl("https://your-proxy.com/api");

var client = new CortiClient(environment: env);