Providers

Prompty uses a provider system to connect to different LLM backends. Each provider has an executor (sends requests to the API) and a processor (extracts results from responses). You set the provider in your .prompty file’s model section.

model:
  id: gpt-4o
  provider: openai        # ← provider key
  apiType: chat
  connection:
    kind: key
    endpoint: ${env:OPENAI_ENDPOINT}
    apiKey: ${env:OPENAI_API_KEY}

---

OpenAI

Direct access to the OpenAI API.

Provider key: openai

Supported API types: chat, responses, embedding, image

Connection

model:
  id: gpt-4o
  provider: openai
  apiType: chat
  connection:
    kind: key
    endpoint: https://api.openai.com/v1
    apiKey: ${env:OPENAI_API_KEY}
  options:
    temperature: 0.7
    maxOutputTokens: 1000

Embedding

model:
  id: text-embedding-3-small
  provider: openai
  apiType: embedding
  connection:
    kind: key
    apiKey: ${env:OPENAI_API_KEY}

Image

model:
  id: dall-e-3
  provider: openai
  apiType: image
  connection:
    kind: key
    apiKey: ${env:OPENAI_API_KEY}
  options:
    additionalProperties:
      size: "1024x1024"
      quality: standard

Tip

The endpoint defaults to https://api.openai.com/v1 and can be omitted for standard OpenAI usage.

Notes

• SDKs: Python — openai package · TypeScript — openai npm package · C# — OpenAI NuGet package
• Supports streaming via PromptyStream / AsyncPromptyStream (Python), async iterables (TypeScript), and IAsyncEnumerable (C#)
• Structured output is supported via outputs → response_format
• Agent mode is available via turn() — it uses apiType: chat with an automatic tool-calling loop

---

Microsoft Foundry

Connect to models deployed through Microsoft Foundry (Azure AI Services). This provider covers both Foundry project endpoints (the recommended approach) and classic Azure OpenAI endpoints (legacy).

Provider key: foundry

Supported API types: chat, responses, embedding, image

Project Endpoint (API Key)

model:
  id: gpt-4o
  provider: foundry
  apiType: chat
  connection:
    kind: key
    endpoint: ${env:AZURE_AI_PROJECT_ENDPOINT}
    apiKey: ${env:AZURE_AI_PROJECT_KEY}
  options:
    temperature: 0.7

Project Endpoint (Entra ID)

model:
  id: gpt-4o
  provider: foundry
  apiType: chat
  connection:
    kind: foundry
    endpoint: ${env:AZURE_AI_PROJECT_ENDPOINT}

Classic Endpoint (API Key)

model:
  id: gpt-4o                # your deployment name
  provider: foundry
  apiType: chat
  connection:
    kind: key
    endpoint: ${env:AZURE_OPENAI_ENDPOINT}
    apiKey: ${env:AZURE_OPENAI_API_KEY}
  options:
    temperature: 0.7

Embedding

model:
  id: text-embedding-3-small  # your deployment name
  provider: foundry
  apiType: embedding
  connection:
    kind: key
    endpoint: ${env:AZURE_AI_PROJECT_ENDPOINT}
    apiKey: ${env:AZURE_AI_PROJECT_KEY}

Migrating from Azure OpenAI?

If your .prompty files use provider: azure, they still work — it’s a deprecated alias for provider: foundry. Update when convenient.

Note

The model.id field maps to your deployment name, not the underlying model name. For example, if you deployed gpt-4o as my-gpt4o-deployment, use id: my-gpt4o-deployment.

Endpoint Patterns

Endpoint Pattern	Example	Notes
Foundry project (recommended)	https://<resource>.services.ai.azure.com/api/projects/<project>	New-style Foundry project endpoint
Classic Azure OpenAI (legacy)	https://<resource>.openai.azure.com/	Still supported via provider: foundry

Notes

• SDKs: Python — openai + azure-identity packages · TypeScript — openai + @azure/identity npm packages · C# — OpenAI + Azure.Identity NuGet packages
• Supports both API key and Microsoft Entra ID (managed identity / DefaultAzureCredential)
• Supports the same features as the OpenAI provider (streaming, structured output, agent mode)
• Model deployments are managed through the Azure AI Foundry portal

---

Anthropic

Access Anthropic Claude models directly.

Provider key: anthropic

Supported API types: chat

Connection

model:
  id: claude-sonnet-4-6
  provider: anthropic
  apiType: chat
  connection:
    kind: key
    endpoint: https://api.anthropic.com
    apiKey: ${env:ANTHROPIC_API_KEY}
  options:
    temperature: 0.7
    maxOutputTokens: 1024

Notes

• SDKs: Python — anthropic package · TypeScript — @anthropic-ai/sdk npm package · C# — Anthropic NuGet package
• The endpoint defaults to https://api.anthropic.com and can typically be omitted
• Tool calling is supported through Anthropic’s native tool use API

---

Provider Comparison

Feature	OpenAI	Microsoft Foundry	Anthropic
chat	✅	✅	✅
responses	✅	✅	❌
embedding	✅	✅	❌
image	✅	✅	❌
agent (tool loop)	✅	✅	❌
Streaming	✅	✅	✅
Structured output	✅	✅	✅
Entra ID auth	❌	✅	❌

---

Custom Providers

The provider system is extensible. You can create your own provider by implementing the executor and processor interfaces, then registering them with the runtime.

1. Implement the Protocols

Python

from prompty.core.protocols import ExecutorProtocol, ProcessorProtocol
from prompty.core.types import Message

class MyExecutor:
    def execute(self, agent, messages: list[Message], **kwargs):
        # Call your LLM API here
        ...

    async def execute_async(self, agent, messages: list[Message], **kwargs):
        # Async variant
        ...

class MyProcessor:
    def process(self, agent, response, **kwargs):
        # Extract content from the API response
        ...

    async def process_async(self, agent, response, **kwargs):
        ...

TypeScript

import { ExecutorProtocol, ProcessorProtocol, Message } from "@prompty/core";

export class MyExecutor implements ExecutorProtocol {
  async execute(agent: Prompty, messages: Message[]): Promise<unknown> {
    // Call your LLM API here
  }
}

export class MyProcessor implements ProcessorProtocol {
  async process(agent: Prompty, response: unknown): Promise<string> {
    // Extract content from the API response
  }
}

C#

using Prompty.Core;

public class MyExecutor : IExecutor
{
    public async Task<object> ExecuteAsync(
        Prompty agent, IList<Message> messages)
    {
        // Call your LLM API here
    }
}

public class MyProcessor : IProcessor
{
    public async Task<string> ProcessAsync(
        Prompty agent, object response)
    {
        // Extract content from the API response
    }
}

Rust

use prompty::types::Message;
use async_trait::async_trait;

pub struct MyExecutor;

#[async_trait]
impl prompty::Executor for MyExecutor {
    async fn execute(
        &self,
        agent: &prompty::Prompty,
        messages: &[Message],
    ) -> Result<serde_json::Value, Box<dyn std::error::Error>> {
        // Call your LLM API here
        todo!()
    }
}

pub struct MyProcessor;

#[async_trait]
impl prompty::Processor for MyProcessor {
    async fn process(
        &self,
        agent: &prompty::Prompty,
        response: serde_json::Value,
    ) -> Result<serde_json::Value, Box<dyn std::error::Error>> {
        // Extract content from the API response
        todo!()
    }
}

2. Register Your Provider

Python

In your package’s pyproject.toml:

[project.entry-points."prompty.executors"]
myprovider = "my_package.executor:MyExecutor"

[project.entry-points."prompty.processors"]
myprovider = "my_package.processor:MyProcessor"

After installing your package, the runtime discovers your provider automatically via the entry point system.

TypeScript

Register the provider at startup:

import { InvokerRegistry } from "@prompty/core";
import { MyExecutor, MyProcessor } from "./my-provider.js";

InvokerRegistry.registerExecutor("myprovider", new MyExecutor());
InvokerRegistry.registerProcessor("myprovider", new MyProcessor());

C#

Register via the fluent builder or directly:

using Prompty.Core;

// Fluent builder
new PromptyBuilder()
    .AddProvider("myprovider", new MyExecutor(), new MyProcessor());

// Or register directly
InvokerRegistry.RegisterExecutor("myprovider", new MyExecutor());
InvokerRegistry.RegisterProcessor("myprovider", new MyProcessor());

Rust

Register at startup via function calls:

prompty::register_defaults();
prompty::register_executor("myprovider", MyExecutor);
prompty::register_processor("myprovider", MyProcessor);

3. Use in .prompty Files

model:
  id: my-model
  provider: myprovider
  connection:
    kind: key
    endpoint: ${env:MY_ENDPOINT}
    apiKey: ${env:MY_API_KEY}

No changes to the Prompty codebase are needed — the .prompty file format is the same regardless of which runtime you use.

Tip

See the pipeline documentation for details on how executors and processors fit into the overall execution flow.