Agents Completions API

https://api.ajan.io/agent/v1/chat/completions

interface UIMessage {
  id: string;           // Unique identifier for this message
  role: 'system' | 'user' | 'assistant';
  parts: MessagePart[]; // Array of message parts
  metadata?: {          // Optional metadata
    attachments?: string[];  // Array of attachment UUIDs
  };
}

{
  id: "msg_1",
  role: "user",
  parts: [
    {
      type: "text",
      text: "Hello, how are you?"
    }
  ]
}

{
  id: "msg_2",
  role: "user",
  parts: [
    {
      type: "text",
      text: "Please analyze this document"
    }
  ],
  metadata: {
    attachments: ["550e8400-e29b-41d4-a716-446655440000"]
  }
}

{
  id: "msg_3",
  role: "assistant",
  parts: [
    {
      type: "tool-webSearch",
      toolCallId: "call_123",
      state: "output-available",
      input: {
        query: "latest news"
      },
      output: { /* search results */ }
    }
  ]
}

'use client';

import { useChat } from '@ai-sdk/react';

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    api: 'https://api.ajan.io/agent/v1/chat/completions',
    headers: {
      'Authorization': `Bearer ${process.env.NEXT_PUBLIC_AJAN_API_KEY}`
    },
    body: {
      agentId: 'your-agent-id'
    }
  });

  return (
    
      {messages.map(m => (
        
          {m.role === 'user' ? 'User: ' : 'AI: '}
          {m.content}
        
      ))}

      
        
      
    
  );
}

const response = await fetch('https://api.ajan.io/agent/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    agentId: 'agent_123',
    messages: [
      {
        id: 'msg_1',
        role: 'user',
        parts: [{ type: 'text', text: 'Hello' }]
      }
    ],
    stream: true
  }),
});

const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  const chunk = decoder.decode(value);
  console.log(chunk);  // Process streaming chunks
}

interface CompletionResponse {
  messages: Array<{
    id: string;
    role: "assistant";
    content: string;
  }>;

  // Structured output - included when requested
  output?: object | array | string;
}

const response = await fetch(
  "https://api.ajan.io/agent/v1/chat/completions",
  {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      agentId: "agent_123",
      messages: [
        {
          id: "msg_1",
          role: "user",
          parts: [
            {
              type: "text",
              text: "Can you analyze this document for me?"
            }
          ],
          metadata: {
            attachments: ["550e8400-e29b-41d4-a716-446655440000"]
          }
        }
      ]
    })
  }
);

const data = await response.json();
const responseText = data.messages[0].content;
console.log(responseText);

const response = await fetch(
  "https://api.ajan.io/agent/v1/chat/completions",
  {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      agent: {
        name: "Document Analyzer",
        instructions: "You are a helpful agent who analyzes documents and answers questions about them",
        temperature: 0.7,
        model: "gpt-5",
        capabilities: {
          webSearch: true
        }
      },
      messages: [
        {
          id: "msg_1",
          role: "user",
          parts: [
            {
              type: "text",
              text: "What are the key points in the document?"
            }
          ]
        }
      ]
    })
  }
);

const data = await response.json();
console.log(data);

const response = await fetch(
  "https://api.ajan.io/agent/v1/chat/completions",
  {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      agent: {
        name: "Weather Agent",
        instructions: "You are a helpful weather agent",
        model: "gpt-5",
        capabilities: {
          webSearch: true
        }
      },
      messages: [
        {
          id: "msg_1",
          role: "user",
          parts: [
            {
              type: "text",
              text: "What's the weather in Paris, Berlin and London today?"
            }
          ]
        }
      ],
      output: {
        type: "array",
        schema: {
          type: "object",
          properties: {
            weather: {
              type: "object",
              properties: {
                city: { type: "string" },
                tempInCelsius: { type: "number" },
                tempInFahrenheit: { type: "number" }
              },
              required: ["city", "tempInCelsius", "tempInFahrenheit"]
            }
          }
        }
      }
    })
  }
);

const data = await response.json();
console.log(data.output);
// Output:
// [
//   { "weather": { "city": "Paris", "tempInCelsius": 1, "tempInFahrenheit": 33 } },
//   { "weather": { "city": "Berlin", "tempInCelsius": 1, "tempInFahrenheit": 35 } },
//   { "weather": { "city": "London", "tempInCelsius": 7, "tempInFahrenheit": 45 } }
// ]

// app/actions.ts
'use server';

import { generateId } from 'ai';

export async function chatWithAgent(message: string) {
  const response = await fetch(
    'https://api.ajan.io/agent/v1/chat/completions',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.AJAN_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        agentId: process.env.AGENT_ID,
        messages: [
          {
            id: generateId(),
            role: 'user',
            parts: [
              {
                type: 'text',
                text: message
              }
            ]
          }
        ]
      })
    }
  );

  const data = await response.json();
  return data.messages[0].content;
}

try {
  const response = await fetch('https://api.ajan.io/agent/v1/chat/completions', options);

  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.message || 'Request failed');
  }

  const data = await response.json();
  // Process response
} catch (error) {
  console.error('Error:', error.message);
}

openapi: 3.0.0
info:
  title: ajan API
  version: 3.0.0
servers:
  - url: https://api.ajan.io
    description: Production
security:
  - bearerAuth: []
paths:
  /agent/v1/chat/completions:
    post:
      tags:
        - Agent
      summary: Creates a chat completion with an agent (Vercel AI SDK compatible)
      description: Creates a model response using Vercel AI SDK compatible UIMessage format
      parameters: []
      requestBody:
        required: true
        content:
          application/json:
            examples:
              streamingEnabled:
                summary: Request with streaming enabled
                value:
                  agentId: agent_123
                  messages:
                    - id: msg_1
                      role: user
                      parts:
                        - type: text
                          text: Hello, how can you help me?
                  stream: true
            schema:
              type: object
              oneOf:
                - type: object
                  required:
                    - agentId
                    - messages
                  properties:
                    agentId:
                      type: string
                      description: ID of an existing agent to use
                    messages:
                      type: array
                      description: Array of UIMessage objects (Vercel AI SDK format)
                      items:
                        type: object
                        required:
                          - id
                          - role
                          - parts
                        properties:
                          id:
                            type: string
                            description: Unique message identifier
                          role:
                            type: string
                            enum:
                              - user
                              - assistant
                              - system
                              - tool
                          parts:
                            type: array
                            items:
                              type: object
                              required:
                                - type
                              properties:
                                type:
                                  type: string
                                  enum:
                                    - text
                                    - file
                                    - tool-invocation
                                    - tool-result
                                text:
                                  type: string
                                  description: Text content for text parts
                                url:
                                  type: string
                                  description: File URL for file parts
                                name:
                                  type: string
                                  description: File name
                                mimeType:
                                  type: string
                                  description: MIME type of the file
                                toolCallId:
                                  type: string
                                  description: Tool call identifier
                                toolName:
                                  type: string
                                  description: Name of the tool
                                args:
                                  type: object
                                  description: Tool arguments
                                result:
                                  type: object
                                  description: Tool result
                    stream:
                      type: boolean
                      default: false
                    output:
                      $ref: '#/components/schemas/StructuredOutputConfig'
                    imageResponseFormat:
                      type: string
                      enum:
                        - url
                        - b64_json
                      description: >-
                        Response format for images generated by the agent. "url"
                        returns a signed URL, "b64_json" returns base64-encoded
                        image data.
      responses:
        '200':
          description: Successful chat completion
          content:
            application/json:
              schema:
                type: object
                description: UIMessage response (Vercel AI SDK format)
                required:
                  - id
                  - role
                  - parts
                properties:
                  id:
                    type: string
                  role:
                    type: string
                    enum:
                      - assistant
                  parts:
                    type: array
                    items:
                      type: object
                  output:
                    description: Structured output if requested
        '400':
          description: Invalid request parameters
        '429':
          description: Rate limit exceeded
        '500':
          description: Internal server error
components:
  schemas:
    StructuredOutputConfig:
      type: object
      description: >-
        Specification for structured output format. When type is object/array
        and no schema is provided, the response will be JSON but can have any
        structure. When the type is enum, you must provide an enum parameter
        with an array of strings as options.
      properties:
        type:
          type: string
          enum:
            - object
            - array
            - enum
          description: The type of structured output
        schema:
          type: object
          description: >-
            JSON Schema definition for the output (required for object/array
            types with specific structure). Search for "JSON to JSON Schema" in
            the web to find a tool to convert any JSON into the required JSON
            Schema format.
        enum:
          type: array
          items:
            type: string
          description: >-
            Array of allowed values (required for enum type). Values must be of
            type string.
      oneOf:
        - properties:
            type:
              enum:
                - enum
            enum:
              items:
                type: string
              type: array
        - properties:
            type:
              enum:
                - object
                - array
            schema:
              type: object
        - properties:
            type:
              enum:
                - object
                - array
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: API Key
      description: API key as Bearer token. Format "Bearer YOUR_API_KEY"