Prompts

from confident_ai import ConfidentAI

client = ConfidentAI()

prompt = client.prompt(prompt_id="<PROMPT-ID>")

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const prompt = client.prompt("<PROMPT-ID>");

from confident_ai import ConfidentAI

client = ConfidentAI()

prompt = client.prompt(alias="greeting")
result = prompt.push(branch="main")

result = await prompt.a_push(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const prompt = client.prompt(undefined, { alias: "greeting" });
const result = await prompt.push({ branch: "main" });

from confident_ai import ConfidentAI

client = ConfidentAI()

prompt = client.prompt(prompt_id="<PROMPT-ID>")
result = prompt.pull(
    commit="<COMMIT>",
    branch="main",
    refresh=60,
    fallback_to_cache=True,
    write_to_cache=True,
    default_to_cache=True,
)

result = await prompt.a_pull(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const prompt = client.prompt("<PROMPT-ID>");
const result = await prompt.pull(
  {
    commit: "<COMMIT>",
    branch: "main",
    refresh: 60,
    fallbackToCache: true,
    writeToCache: true,
    defaultToCache: true
  },
);

from confident_ai import ConfidentAI

client = ConfidentAI()

prompt = client.prompt(prompt_id="<PROMPT-ID>")
prompt.pull()
result = prompt.interpolate()

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const prompt = client.prompt("<PROMPT-ID>");
await prompt.pull();
const result = await prompt.interpolate();

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.prompts.list()

result = await client.prompts.a_list(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.prompts.list();

from confident_ai import ConfidentAI
from confident_ai.common import ModelProvider
from confident_ai.prompts import ModelSettings
from confident_ai.prompts import OutputSchema
from confident_ai.prompts import OutputSchemaField
from confident_ai.prompts import PromptInterpolationType
from confident_ai.prompts import PromptOutputType
from confident_ai.prompts import PushTextPrompt
from confident_ai.prompts import ReasoningEffort
from confident_ai.prompts import StructuredSchema
from confident_ai.prompts import Tool
from confident_ai.prompts import ToolMode
from confident_ai.prompts import Verbosity

client = ConfidentAI()

result = client.prompts.push(
    prompt=PushTextPrompt(
        text="Hello, {{name}}! How can I help you today?",
        alias="greeting",
        interpolation_type=PromptInterpolationType.MUSTACHE,
        model_settings=ModelSettings(
            provider=ModelProvider.OPEN_AI,
            name="gpt-4o",
            temperature=0.7,
            max_tokens=1024,
            top_p=1,
            top_k=40,
            frequency_penalty=0,
            presence_penalty=0,
            stop_sequence=["\n\nHuman:", "###"],
            reasoning_effort=ReasoningEffort.MINIMAL,
            verbosity=Verbosity.LOW
        ),
        output_type=PromptOutputType.TEXT,
        output_schema=OutputSchema(
            name="Greeting",
            fields=[
                OutputSchemaField(
                    id="<FIELD-ID>",
                    name="greeting",
                    type=...,
                    required=True,
                    parent_id="<PARENT-ID>"
                )
            ]
        ),
        tools=[
            Tool(
                id="<TOOL-ID>",
                name="get_customer_name",
                description="Looks up the customer's name by id.",
                mode=ToolMode.ALLOW_ADDITIONAL,
                structured_schema=StructuredSchema(
                    id="<STRUCTURED-SCHEMA-ID>",
                    name="GetCustomerNameInput",
                    fields=[
                        ...
                    ]
                )
            )
        ],
        branch="main"
    ),
)

result = await client.prompts.a_push(...)

import { ConfidentAI } from "confident-ai";
import { ModelProvider } from "confident-ai/common";
import {
  PromptInterpolationType,
  PromptOutputType,
  ReasoningEffort,
  ToolMode,
  Verbosity,
} from "confident-ai/prompts";

const client = new ConfidentAI();

const result = await client.prompts.push(
  {
    text: "Hello, {{name}}! How can I help you today?",
    alias: "greeting",
    interpolationType: PromptInterpolationType.MUSTACHE,
    modelSettings: {
        provider: ModelProvider.OPEN_AI,
        name: "gpt-4o",
        temperature: 0.7,
        maxTokens: 1024,
        topP: 1,
        topK: 40,
        frequencyPenalty: 0,
        presencePenalty: 0,
        stopSequence: ["\n\nHuman:", "###"],
        reasoningEffort: ReasoningEffort.MINIMAL,
        verbosity: Verbosity.LOW
      },
    outputType: PromptOutputType.TEXT,
    outputSchema: {
        name: "Greeting",
        fields: [
            {
              id: "<FIELD-ID>",
              name: "greeting",
              type: {},
              required: true,
              parentId: "<PARENT-ID>"
            }
          ]
      },
    tools: [
        {
          id: "<TOOL-ID>",
          name: "get_customer_name",
          description: "Looks up the customer's name by id.",
          mode: ToolMode.ALLOW_ADDITIONAL,
          structuredSchema: {
              id: "<STRUCTURED-SCHEMA-ID>",
              name: "GetCustomerNameInput",
              fields: [
                  {}
                ]
            }
        }
      ],
    branch: "main"
  },
);

from confident_ai import ConfidentAI
from confident_ai.common import ModelProvider
from confident_ai.prompts import ModelSettings
from confident_ai.prompts import OutputSchema
from confident_ai.prompts import OutputSchemaField
from confident_ai.prompts import PromptInterpolationType
from confident_ai.prompts import PromptOutputType
from confident_ai.prompts import PushMessagesPrompt
from confident_ai.prompts import ReasoningEffort
from confident_ai.prompts import StructuredSchema
from confident_ai.prompts import Tool
from confident_ai.prompts import ToolMode
from confident_ai.prompts import Verbosity

client = ConfidentAI()

result = client.prompts.push(
    prompt=PushMessagesPrompt(
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {
                "role": "user",
                "content": "Hello, {{name}}! How can I help you today?"
            }
        ],
        alias="greeting",
        interpolation_type=PromptInterpolationType.MUSTACHE,
        model_settings=ModelSettings(
            provider=ModelProvider.OPEN_AI,
            name="gpt-4o",
            temperature=0.7,
            max_tokens=1024,
            top_p=1,
            top_k=40,
            frequency_penalty=0,
            presence_penalty=0,
            stop_sequence=["\n\nHuman:", "###"],
            reasoning_effort=ReasoningEffort.MINIMAL,
            verbosity=Verbosity.LOW
        ),
        output_type=PromptOutputType.TEXT,
        output_schema=OutputSchema(
            name="Greeting",
            fields=[
                OutputSchemaField(
                    id="<FIELD-ID>",
                    name="greeting",
                    type=...,
                    required=True,
                    parent_id="<PARENT-ID>"
                )
            ]
        ),
        tools=[
            Tool(
                id="<TOOL-ID>",
                name="get_customer_name",
                description="Looks up the customer's name by id.",
                mode=ToolMode.ALLOW_ADDITIONAL,
                structured_schema=StructuredSchema(
                    id="<STRUCTURED-SCHEMA-ID>",
                    name="GetCustomerNameInput",
                    fields=[
                        ...
                    ]
                )
            )
        ],
        branch="main"
    ),
)

result = await client.prompts.a_push(...)

import { ConfidentAI } from "confident-ai";
import { ModelProvider } from "confident-ai/common";
import {
  PromptInterpolationType,
  PromptOutputType,
  ReasoningEffort,
  ToolMode,
  Verbosity,
} from "confident-ai/prompts";

const client = new ConfidentAI();

const result = await client.prompts.push(
  {
    messages: [
        { role: "system", content: "You are a helpful assistant." },
        {
          role: "user",
          content: "Hello, {{name}}! How can I help you today?"
        }
      ],
    alias: "greeting",
    interpolationType: PromptInterpolationType.MUSTACHE,
    modelSettings: {
        provider: ModelProvider.OPEN_AI,
        name: "gpt-4o",
        temperature: 0.7,
        maxTokens: 1024,
        topP: 1,
        topK: 40,
        frequencyPenalty: 0,
        presencePenalty: 0,
        stopSequence: ["\n\nHuman:", "###"],
        reasoningEffort: ReasoningEffort.MINIMAL,
        verbosity: Verbosity.LOW
      },
    outputType: PromptOutputType.TEXT,
    outputSchema: {
        name: "Greeting",
        fields: [
            {
              id: "<FIELD-ID>",
              name: "greeting",
              type: {},
              required: true,
              parentId: "<PARENT-ID>"
            }
          ]
      },
    tools: [
        {
          id: "<TOOL-ID>",
          name: "get_customer_name",
          description: "Looks up the customer's name by id.",
          mode: ToolMode.ALLOW_ADDITIONAL,
          structuredSchema: {
              id: "<STRUCTURED-SCHEMA-ID>",
              name: "GetCustomerNameInput",
              fields: [
                  {}
                ]
            }
        }
      ],
    branch: "main"
  },
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.prompts.get_by_label(
    prompt_id="<PROMPT-ID>",
    label="production",
)

result = await client.prompts.a_get_by_label(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.prompts.getByLabel("<PROMPT-ID>", "production");

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.prompts.get_by_commit(
    prompt_id="<PROMPT-ID>",
    hash="bab04ce",
    branch="main",
)

result = await client.prompts.a_get_by_commit(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.prompts.getByCommit(
  "<PROMPT-ID>",
  "bab04ce",
  { branch: "main" },
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.prompts.get_by_version(
    prompt_id="<PROMPT-ID>",
    version="00.00.01",
)

result = await client.prompts.a_get_by_version(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.prompts.getByVersion("<PROMPT-ID>", "00.00.01");

class ModelProvider(Enum):
    OPEN_AI = "OPEN_AI"
    CUSTOM = "CUSTOM"
    CONFIDENT_AI = "CONFIDENT_AI"
    BEDROCK = "BEDROCK"
    ANTHROPIC = "ANTHROPIC"
    GEMINI = "GEMINI"
    X_AI = "X_AI"
    DEEPSEEK = "DEEPSEEK"
    MOONSHOT_AI = "MOONSHOT_AI"
    VERTEX_AI = "VERTEX_AI"
    AZURE = "AZURE"
    MISTRAL = "MISTRAL"
    PERPLEXITY = "PERPLEXITY"
    OPEN_ROUTER = "OPEN_ROUTER"
    PORTKEY = "PORTKEY"
    LITE_LLM = "LITE_LLM"
    TRUE_FOUNDRY = "TRUE_FOUNDRY"
    HUGGING_FACE = "HUGGING_FACE"
    TYPE_SAFE = "TYPE_SAFE"
    FAL = "FAL"

enum ModelProvider {
  OPEN_AI = "OPEN_AI",
  CUSTOM = "CUSTOM",
  CONFIDENT_AI = "CONFIDENT_AI",
  BEDROCK = "BEDROCK",
  ANTHROPIC = "ANTHROPIC",
  GEMINI = "GEMINI",
  X_AI = "X_AI",
  DEEPSEEK = "DEEPSEEK",
  MOONSHOT_AI = "MOONSHOT_AI",
  VERTEX_AI = "VERTEX_AI",
  AZURE = "AZURE",
  MISTRAL = "MISTRAL",
  PERPLEXITY = "PERPLEXITY",
  OPEN_ROUTER = "OPEN_ROUTER",
  PORTKEY = "PORTKEY",
  LITE_LLM = "LITE_LLM",
  TRUE_FOUNDRY = "TRUE_FOUNDRY",
  HUGGING_FACE = "HUGGING_FACE",
  TYPE_SAFE = "TYPE_SAFE",
  FAL = "FAL",
}

class ModelSettings:
    provider: Optional[ModelProvider] = None
    name: Optional[str] = None
    temperature: Optional[float] = None
    max_tokens: Optional[float] = Field(default=None, alias="maxTokens")
    top_p: Optional[float] = Field(default=None, alias="topP")
    top_k: Optional[float] = Field(default=None, alias="topK")
    frequency_penalty: Optional[float] = Field(default=None, alias="frequencyPenalty")
    presence_penalty: Optional[float] = Field(default=None, alias="presencePenalty")
    stop_sequence: Optional[List[str]] = Field(default=None, alias="stopSequence")
    reasoning_effort: Optional[ReasoningEffort] = Field(default=None, alias="reasoningEffort")
    verbosity: Optional[Verbosity] = None

interface ModelSettings {
  provider?: ModelProvider;
  name?: string;
  temperature?: number;
  maxTokens?: number;
  topP?: number;
  topK?: number;
  frequencyPenalty?: number;
  presencePenalty?: number;
  stopSequence?: string[];
  reasoningEffort?: ReasoningEffort;
  verbosity?: Verbosity;
}

class OutputSchema:
    name: str
    fields: List[OutputSchemaField]

interface OutputSchema {
  name: string;
  fields: OutputSchemaField[];
}

class OutputSchemaField:
    id: Optional[str] = None
    name: str
    type: SchemaDataType
    required: Optional[bool] = None
    parent_id: Optional[str] = Field(default=None, alias="parentId")

interface OutputSchemaField {
  id?: string;
  name: string;
  type: SchemaDataType;
  required?: boolean;
  parentId?: string | null;
}

Prompt = Union[
    TextPrompt,
    MessagesPrompt,
]

type Prompt =
  | TextPrompt
  | MessagesPrompt;

class PromptInterpolationType(Enum):
    MUSTACHE = "MUSTACHE"
    MUSTACHE_WITH_SPACE = "MUSTACHE_WITH_SPACE"
    FSTRING = "FSTRING"
    DOLLAR_BRACKETS = "DOLLAR_BRACKETS"
    JINJA = "JINJA"

enum PromptInterpolationType {
  MUSTACHE = "MUSTACHE",
  MUSTACHE_WITH_SPACE = "MUSTACHE_WITH_SPACE",
  FSTRING = "FSTRING",
  DOLLAR_BRACKETS = "DOLLAR_BRACKETS",
  JINJA = "JINJA",
}

class PromptList:
    prompts: List[PromptSummary]

interface PromptList {
  prompts: PromptSummary[];
}

class PromptMessage:
    role: str
    content: str

interface PromptMessage {
  role: string;
  content: string;
}

class PromptOutputType(Enum):
    TEXT = "TEXT"
    JSON = "JSON"
    SCHEMA = "SCHEMA"

enum PromptOutputType {
  TEXT = "TEXT",
  JSON = "JSON",
  SCHEMA = "SCHEMA",
}

class PromptSummary:
    id: str
    alias: str
    type: PromptType

interface PromptSummary {
  id: string;
  alias: string;
  type: PromptType;
}

class PromptType(Enum):
    TEXT = "TEXT"
    LIST = "LIST"

enum PromptType {
  TEXT = "TEXT",
  LIST = "LIST",
}

PushPromptRequest = Union[
    PushTextPrompt,
    PushMessagesPrompt,
]

type PushPromptRequest =
  | PushTextPrompt
  | PushMessagesPrompt;

class PushPromptResult:
    prompt_id: str = Field(alias="promptId")
    hash: str

interface PushPromptResult {
  promptId: string;
  hash: string;
}

class ReasoningEffort(Enum):
    MINIMAL = "MINIMAL"
    LOW = "LOW"
    MEDIUM = "MEDIUM"
    HIGH = "HIGH"

enum ReasoningEffort {
  MINIMAL = "MINIMAL",
  LOW = "LOW",
  MEDIUM = "MEDIUM",
  HIGH = "HIGH",
}

class SchemaDataType(Enum):
    OBJECT = "OBJECT"
    ARRAY = "ARRAY"
    STRING = "STRING"
    FLOAT = "FLOAT"
    INTEGER = "INTEGER"
    BOOLEAN = "BOOLEAN"
    NULL = "NULL"

enum SchemaDataType {
  OBJECT = "OBJECT",
  ARRAY = "ARRAY",
  STRING = "STRING",
  FLOAT = "FLOAT",
  INTEGER = "INTEGER",
  BOOLEAN = "BOOLEAN",
  NULL = "NULL",
}

class StructuredSchema:
    id: Optional[str] = None
    name: Optional[str] = None
    fields: List[StructuredSchemaField]

interface StructuredSchema {
  id?: string;
  name?: string | null;
  fields: StructuredSchemaField[];
}

class StructuredSchemaField:
    id: str
    name: Optional[str] = None
    description: Optional[str] = None
    type: SchemaDataType
    required: Optional[bool] = None
    parent_id: Optional[str] = Field(default=None, alias="parentId")

interface StructuredSchemaField {
  id: string;
  name?: string | null;
  description?: string | null;
  type: SchemaDataType;
  required?: boolean;
  parentId?: string | null;
}

class Tool:
    id: Optional[str] = None
    name: str
    description: Optional[str] = None
    mode: ToolMode
    structured_schema: StructuredSchema = Field(alias="structuredSchema")

interface Tool {
  id?: string;
  name: string;
  description?: string | null;
  mode: ToolMode;
  structuredSchema: StructuredSchema;
}

class ToolMode(Enum):
    ALLOW_ADDITIONAL = "ALLOW_ADDITIONAL"
    NO_ADDITIONAL = "NO_ADDITIONAL"
    STRICT = "STRICT"

enum ToolMode {
  ALLOW_ADDITIONAL = "ALLOW_ADDITIONAL",
  NO_ADDITIONAL = "NO_ADDITIONAL",
  STRICT = "STRICT",
}

class Verbosity(Enum):
    LOW = "LOW"
    MEDIUM = "MEDIUM"
    HIGH = "HIGH"

enum Verbosity {
  LOW = "LOW",
  MEDIUM = "MEDIUM",
  HIGH = "HIGH",
}