Skip to main content

​
Overview

Deployment types represent deployed prompts with their complete configuration, messages, tools, and variables.

​
Deployment

A specific instance of a prompt that has been deployed to an environment. 
interface Deployment {
  id: string;
  createdAt: UnixTimestamp;
  updatedAt: UnixTimestamp;
  createdByUserId: string;
  updatedByUserId: string;
  projectId: string;
  promptId: string;
  deploymentEnvironmentId: string;
  prompt: DeploymentPrompt;
}
Properties:
  • id - Deployment identifier
  • createdAt - Creation timestamp
  • updatedAt - Last update timestamp
  • createdByUserId - Creator user ID
  • updatedByUserId - Last updater user ID
  • projectId - Associated project ID
  • promptId - Associated prompt ID
  • deploymentEnvironmentId - Target environment ID
  • prompt - Complete deployed prompt object
Example: 
import { Adaline } from '@adaline/client';
import type { Deployment } from '@adaline/api';

const adaline = new Adaline();

const deployment: Deployment = await adaline.getLatestDeployment({
  promptId: 'prompt_abc123',
  deploymentEnvironmentId: 'environment_abc123'
});

console.log(`ID: ${deployment.id}`);
console.log(`Model: ${deployment.prompt.config.model}`);
console.log(`Provider: ${deployment.prompt.config.providerName}`);
console.log(`Messages: ${deployment.prompt.messages.length}`);
console.log(`Tools: ${deployment.prompt.tools.length}`);
JSON: 
{
  "id": "deploy_abc123",
  "createdAt": 1704067200000,
  "updatedAt": 1704153600000,
  "createdByUserId": "user_456",
  "updatedByUserId": "user_456",
  "projectId": "proj_789",
  "promptId": "prompt_abc123",
  "deploymentEnvironmentId": "production",
  "prompt": {
    "config": {...},
    "messages": [...],
    "tools": [],
    "variables": []
  }
}

​
DeploymentPrompt

Prompt configuration with messages, tools, config, and variables. 
interface DeploymentPrompt {
  config: DeploymentPromptConfig;
  messages: Message[];
  tools: Tool[];
  variables: DeploymentPromptVariables[];
}
Properties:
  • config - Model provider and settings
  • messages - Array of chat messages
  • tools - Array of available tools/functions
  • variables - Array of variable definitions
JSON: 
{
  "config": {
    "providerName": "openai",
    "providerId": "provider_123",
    "model": "gpt-4o",
    "settings": { "temperature": 0.7 }
  },
  "messages": [
    {
      "role": "system",
      "content": [{ "modality": "text", "value": "You are helpful." }]
    }
  ],
  "tools": [],
  "variables": []
}

​
DeploymentPromptConfig

Model provider and settings configuration. 
interface DeploymentPromptConfig {
  providerName: string;
  providerId: string;
  model: string;
  settings: Record<string, any>;
}
Properties:
  • providerName - Provider name (e.g., ‘openai’, ‘anthropic’, ‘google’)
  • providerId - Adaline internal provider UUID
  • model - Model identifier (e.g., ‘gpt-4o’, ‘claude-3-opus’)
  • settings - Provider-specific runtime configuration
JSON: 
{
  "providerName": "openai",
  "providerId": "provider_abc123",
  "model": "gpt-4o",
  "settings": {
    "temperature": 0.7,
    "maxTokens": 1000
  }
}

​
DeploymentPromptVariables

Prompt variable definitions. 
interface DeploymentPromptVariables {
  name: string;
  modality: 'text' | 'image' | 'pdf';
}
Properties:
  • name - Variable name (used as {{variable_name}} in prompts)
  • modality - Variable type (text, image, or pdf)
JSON: 
[
  { "name": "user_name", "modality": "text" },
  { "name": "company", "modality": "text" }
]

​
Complete Example

import { Adaline } from '@adaline/client';
import type {
  Deployment,
  DeploymentPrompt,
  DeploymentPromptConfig,
  DeploymentPromptVariables
} from '@adaline/api';
import { Gateway } from '@adaline/gateway';
import { OpenAI } from '@adaline/openai';
import { Anthropic } from '@adaline/anthropic';

const adaline = new Adaline();
const gateway = new Gateway();

async function useDeployment() {
  // Get deployment from Adaline
  const deployment: Deployment = await adaline.getLatestDeployment({
    promptId: 'prompt_abc123',
    deploymentEnvironmentId: 'environment_abc123'
  });

  // Access deployed prompt configuration
  const prompt: DeploymentPrompt = deployment.prompt;
  const config: DeploymentPromptConfig = prompt.config;
  const variables: DeploymentPromptVariables[] = prompt.variables;

  console.log('Deployed Prompt Configuration:');
  console.log(`  Provider: ${config.providerName}`);
  console.log(`  Model: ${config.model}`);
  console.log(`  Settings:`, config.settings);
  console.log(`  Messages: ${prompt.messages.length}`);
  console.log(`  Tools: ${prompt.tools.length}`);
  console.log(`  Variables: ${variables.map(v => v.name).join(', ')}`);

  // Create provider and model based on deployment config
  let model;

  if (config.providerName === 'openai') {
    const openai = new OpenAI();
    model = openai.chatModel({
      modelName: config.model,
      apiKey: process.env.OPENAI_API_KEY!
    });
  } else if (config.providerName === 'anthropic') {
    const anthropic = new Anthropic();
    model = anthropic.chatModel({
      modelName: config.model,
      apiKey: process.env.ANTHROPIC_API_KEY!
    });
  }

  // Call LLM using Adaline Gateway
  const response = await gateway.completeChat({
    model,
    config: config.settings,
    messages: prompt.messages,
    tools: prompt.tools
  });

  return response.response.messages[0].content[0].value;
}