gpt-6-astra

最后更新：2026-11-14

POSThttps://www.sagelib.com/responses

gpt-6-astra 模型的响应生成接口，OpenAI 兼容协议，支持多轮上下文、流式输出、工具调用、结构化输出等。

接口鉴权方式请参考：API接入与鉴权

请求参数

请求头

参数名称	描述
*Content-Type `string`	可选值：application/json application/json
*Authorization `string`	鉴权令牌，格式为 Bearer ${AIGATEWAY_TOKEN}

Body 参数

参数名称	描述
*model `string`	可选值：gpt-6-astra 模型标识名，固定为 gpt-6-astra
*input `string`	可选值：String or array of message objects 对话输入，支持字符串或消息对象数组（含 role/content），图像经 input_image 块传入（detail: auto/low/high）
instructions `string`	系统指令，插入对话最前
max_output_tokens `integer`	可选值：≤128K 输出 token 上限（含推理 token）
reasoning `object`	可选值：medium、high、xhigh、concise、current_turn、pro 推理配置对象，effort 控制推理深度档位
text `object`	可选值：json_object、medium、high 输出格式配置，支持结构化输出与详细程度控制
tools `array`	可选值：Array of tool definitions 工具定义列表，支持 function 类型
tool_choice `string`	默认值：auto 可选值：none、auto 工具选择策略
parallel_tool_calls `boolean`	默认值：true 可选值：true、false 是否允许并行工具调用
max_tool_calls `integer`	单请求内置工具总调用上限
previous_response_id `string`	前序响应 ID，用于多轮续接
background `boolean`	默认值：false 可选值：true、false 后台模式，适用于长任务防超时
include `array`	可选值：reasoning.encrypted_content etc. 附加回带项
stream `boolean`	默认值：false 可选值：true、false 是否以 SSE 流式返回
service_tier `string`	默认值：auto 可选值：auto、default、flex、priority、fast 服务层级选择
store `boolean`	默认值：false 可选值：true、false 是否存储响应供检索
metadata `object`	可选值：Up to 16 pairs, key/value ≤512 characters 附加键值对
safety_identifier `string`	可选值：≤64 characters 稳定用户标识，用于滥用检测
prompt_cache_key `string`	缓存命中优化的稳定 key
prompt_cache_options `object`	可选值：ttl minimum 30m 提示缓存选项

请求示例

curl -v 'https://www.sagelib.com/responses' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": [
      {
        "role": "user",
        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
      }
    ]
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your Bearer token

url = f"https://www.sagelib.com/responses"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "model": "gpt-6-astra",
    "input": [
        {
            "role": "user",
            "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
        }
    ]
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/responses";

        String jsonRequestBody = """
            {
                "model": "gpt-6-astra",
                "input": [
                    {
                        "role": "user",
                        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
                    }
                ]
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            // Use ofInputStream to handle the streaming response
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) {
                            break;
                        }
                        // Tip: you can bring in Gson or Jackson here to parse the JSON in data and extract delta.content
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/responses"

    jsonRequestBody := `
            {
                "model": "gpt-6-astra",
                "input": [
                    {
                        "role": "user",
                        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
                    }
                ]
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    // Pretty-print the returned JSON data
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

curl -v 'https://www.sagelib.com/responses' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": [
      {
        "role": "user",
        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
      }
    ],
    "tools": [
      {
        "type": "function",
        "name": "get_weather",
        "description": "Get weather",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {
              "type": "string"
            }
          },
          "required": [
            "city"
          ]
        }
      }
    ]
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your Bearer token

url = f"https://www.sagelib.com/responses"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "model": "gpt-6-astra",
    "input": [
        {
            "role": "user",
            "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
        }
    ],
    "tools": [
        {
            "type": "function",
            "name": "get_weather",
            "description": "Get weather",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string"
                    }
                },
                "required": [
                    "city"
                ]
            }
        }
    ]
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/responses";

        String jsonRequestBody = """
            {
                "model": "gpt-6-astra",
                "input": [
                    {
                        "role": "user",
                        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
                    }
                ],
                "tools": [
                    {
                        "type": "function",
                        "name": "get_weather",
                        "description": "Get weather",
                        "parameters": {
                            "type": "object",
                            "properties": {
                                "city": {
                                    "type": "string"
                                }
                            },
                            "required": [
                                "city"
                            ]
                        }
                    }
                ]
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            // Use ofInputStream to handle the streaming response
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) {
                            break;
                        }
                        // Tip: you can bring in Gson or Jackson here to parse the JSON in data and extract delta.content
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/responses"

    jsonRequestBody := `
            {
                "model": "gpt-6-astra",
                "input": [
                    {
                        "role": "user",
                        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
                    }
                ],
                "tools": [
                    {
                        "type": "function",
                        "name": "get_weather",
                        "description": "Get weather",
                        "parameters": {
                            "type": "object",
                            "properties": {
                                "city": {
                                    "type": "string"
                                }
                            },
                            "required": [
                                "city"
                            ]
                        }
                    }
                ]
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    // Pretty-print the returned JSON data
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

curl -v 'https://www.sagelib.com/responses' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "input": [
      {
        "content": "[Enterprise Knowledge Base v3.2] The core product is AI Gateway Test Platform, supporting unified access and quality verification for multi-vendor models such as OpenAI/Anthropic/Gemini. 1. Refund policy: unused member subscriptions fully refundable within 7 days; API quota refunded proportionally within 90 days; physical goods accepted within 15 days with 7-day no-reason return. ... (knowledge base long text truncated; original case is an enterprise KB of about 3600 chars repeated 3 times to trigger prompt caching)",
        "role": "user"
      }
    ],
    "model": "gpt-6-astra",
    "prompt_cache_options": {
      "ttl": "30m"
    }
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your Bearer token

url = f"https://www.sagelib.com/responses"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "input": [
        {
            "content": "[Enterprise Knowledge Base v3.2] The core product is AI Gateway Test Platform, supporting unified access and quality verification for multi-vendor models such as OpenAI/Anthropic/Gemini. 1. Refund policy: unused member subscriptions fully refundable within 7 days; API quota refunded proportionally within 90 days; physical goods accepted within 15 days with 7-day no-reason return. ... (knowledge base long text truncated; original case is an enterprise KB of about 3600 chars repeated 3 times to trigger prompt caching)",
            "role": "user"
        }
    ],
    "model": "gpt-6-astra",
    "prompt_cache_options": {
        "ttl": "30m"
    }
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/responses";

        String jsonRequestBody = """
            {
                "input": [
                    {
                        "content": "[Enterprise Knowledge Base v3.2] The core product is AI Gateway Test Platform, supporting unified access and quality verification for multi-vendor models such as OpenAI/Anthropic/Gemini. 1. Refund policy: unused member subscriptions fully refundable within 7 days; API quota refunded proportionally within 90 days; physical goods accepted within 15 days with 7-day no-reason return. ... (knowledge base long text truncated; original case is an enterprise KB of about 3600 chars repeated 3 times to trigger prompt caching)",
                        "role": "user"
                    }
                ],
                "model": "gpt-6-astra",
                "prompt_cache_options": {
                    "ttl": "30m"
                }
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            // Use ofInputStream to handle the streaming response
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) {
                            break;
                        }
                        // Tip: you can bring in Gson or Jackson here to parse the JSON in data and extract delta.content
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/responses"

    jsonRequestBody := `
            {
                "input": [
                    {
                        "content": "[Enterprise Knowledge Base v3.2] The core product is AI Gateway Test Platform, supporting unified access and quality verification for multi-vendor models such as OpenAI/Anthropic/Gemini. 1. Refund policy: unused member subscriptions fully refundable within 7 days; API quota refunded proportionally within 90 days; physical goods accepted within 15 days with 7-day no-reason return. ... (knowledge base long text truncated; original case is an enterprise KB of about 3600 chars repeated 3 times to trigger prompt caching)",
                        "role": "user"
                    }
                ],
                "model": "gpt-6-astra",
                "prompt_cache_options": {
                    "ttl": "30m"
                }
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    // Pretty-print the returned JSON data
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

响应参数

Body 参数

参数名称	描述
id `string`	resp_ 开头的响应 ID
object `string`	固定为 response
model `string`	模型名
status `string`	completed
output `array`	输出数组，含 reasoning（加密）/ message / function_call
usage `object`	input_tokens / output_tokens 及推理明细
service_tier `string`	服务层级回带值

POSThttps://www.sagelib.com/openai/responses

gpt-6-astra 模型的响应生成接口，OpenAI 直连模式，支持多轮上下文、流式输出、工具调用、结构化输出等。

接口鉴权方式请参考：API接入与鉴权

请求参数

请求头

参数名称	描述
*Content-Type `string`	可选值：application/json application/json
*Authorization `string`	鉴权令牌，格式为 Bearer ${AIGATEWAY_TOKEN}

Body 参数

参数名称	描述
*model `string`	可选值：gpt-6-astra 模型标识名，固定为 gpt-6-astra
*input `string`	可选值：String or array of message objects 对话输入，支持字符串或消息对象数组（含 role/content），图像经 input_image 块传入（detail: auto/low/high）
instructions `string`	系统指令，插入对话最前
max_output_tokens `integer`	可选值：≤128K 输出 token 上限（含推理 token）
reasoning `object`	可选值：medium、high、xhigh、concise、current_turn、pro 推理配置对象，effort 控制推理深度档位
text `object`	可选值：json_object、medium、high 输出格式配置，支持结构化输出与详细程度控制
tools `array`	可选值：Array of tool definitions 工具定义列表，支持 function 类型
tool_choice `string`	默认值：auto 可选值：none、auto 工具选择策略
parallel_tool_calls `boolean`	默认值：true 可选值：true、false 是否允许并行工具调用
max_tool_calls `integer`	单请求内置工具总调用上限
previous_response_id `string`	前序响应 ID，用于多轮续接
background `boolean`	默认值：false 可选值：true、false 后台模式，适用于长任务防超时
include `array`	可选值：reasoning.encrypted_content etc. 附加回带项
stream `boolean`	默认值：false 可选值：true、false 是否以 SSE 流式返回
service_tier `string`	默认值：auto 可选值：auto、default、flex、priority、fast 服务层级选择
store `boolean`	默认值：false 可选值：true、false 是否存储响应供检索
metadata `object`	可选值：Up to 16 pairs, key/value ≤512 characters 附加键值对
safety_identifier `string`	可选值：≤64 characters 稳定用户标识，用于滥用检测
prompt_cache_key `string`	缓存命中优化的稳定 key
prompt_cache_options `object`	可选值：ttl minimum 30m 提示缓存选项

请求示例

curl -v 'https://www.sagelib.com/openai/responses' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": [
      {
        "role": "user",
        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
      }
    ]
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your Bearer token

url = f"https://www.sagelib.com/openai/responses"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "model": "gpt-6-astra",
    "input": [
        {
            "role": "user",
            "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
        }
    ]
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/openai/responses";

        String jsonRequestBody = """
            {
                "model": "gpt-6-astra",
                "input": [
                    {
                        "role": "user",
                        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
                    }
                ]
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            // Use ofInputStream to handle the streaming response
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) {
                            break;
                        }
                        // Tip: you can bring in Gson or Jackson here to parse the JSON in data and extract delta.content
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/openai/responses"

    jsonRequestBody := `
            {
                "model": "gpt-6-astra",
                "input": [
                    {
                        "role": "user",
                        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
                    }
                ]
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    // Pretty-print the returned JSON data
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

curl -v 'https://www.sagelib.com/openai/responses' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": [
      {
        "role": "user",
        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
      }
    ],
    "tools": [
      {
        "type": "function",
        "name": "get_weather",
        "description": "Get weather",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {
              "type": "string"
            }
          },
          "required": [
            "city"
          ]
        }
      }
    ]
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your Bearer token

url = f"https://www.sagelib.com/openai/responses"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "model": "gpt-6-astra",
    "input": [
        {
            "role": "user",
            "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
        }
    ],
    "tools": [
        {
            "type": "function",
            "name": "get_weather",
            "description": "Get weather",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string"
                    }
                },
                "required": [
                    "city"
                ]
            }
        }
    ]
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/openai/responses";

        String jsonRequestBody = """
            {
                "model": "gpt-6-astra",
                "input": [
                    {
                        "role": "user",
                        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
                    }
                ],
                "tools": [
                    {
                        "type": "function",
                        "name": "get_weather",
                        "description": "Get weather",
                        "parameters": {
                            "type": "object",
                            "properties": {
                                "city": {
                                    "type": "string"
                                }
                            },
                            "required": [
                                "city"
                            ]
                        }
                    }
                ]
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            // Use ofInputStream to handle the streaming response
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) {
                            break;
                        }
                        // Tip: you can bring in Gson or Jackson here to parse the JSON in data and extract delta.content
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/openai/responses"

    jsonRequestBody := `
            {
                "model": "gpt-6-astra",
                "input": [
                    {
                        "role": "user",
                        "content": "What model are you? Which company made you? When were you launched? Briefly describe your capability boundaries."
                    }
                ],
                "tools": [
                    {
                        "type": "function",
                        "name": "get_weather",
                        "description": "Get weather",
                        "parameters": {
                            "type": "object",
                            "properties": {
                                "city": {
                                    "type": "string"
                                }
                            },
                            "required": [
                                "city"
                            ]
                        }
                    }
                ]
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    // Pretty-print the returned JSON data
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

curl -v 'https://www.sagelib.com/openai/responses' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "input": [
      {
        "content": "[Enterprise Knowledge Base v3.2] The core product is AI Gateway Test Platform, supporting unified access and quality verification for multi-vendor models such as OpenAI/Anthropic/Gemini. 1. Refund policy: unused member subscriptions fully refundable within 7 days; API quota refunded proportionally within 90 days; physical goods accepted within 15 days with 7-day no-reason return. ... (knowledge base long text truncated; original case is an enterprise KB of about 3600 chars repeated 3 times to trigger prompt caching)",
        "role": "user"
      }
    ],
    "model": "gpt-6-astra",
    "prompt_cache_options": {
      "ttl": "30m"
    }
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your Bearer token

url = f"https://www.sagelib.com/openai/responses"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "input": [
        {
            "content": "[Enterprise Knowledge Base v3.2] The core product is AI Gateway Test Platform, supporting unified access and quality verification for multi-vendor models such as OpenAI/Anthropic/Gemini. 1. Refund policy: unused member subscriptions fully refundable within 7 days; API quota refunded proportionally within 90 days; physical goods accepted within 15 days with 7-day no-reason return. ... (knowledge base long text truncated; original case is an enterprise KB of about 3600 chars repeated 3 times to trigger prompt caching)",
            "role": "user"
        }
    ],
    "model": "gpt-6-astra",
    "prompt_cache_options": {
        "ttl": "30m"
    }
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/openai/responses";

        String jsonRequestBody = """
            {
                "input": [
                    {
                        "content": "[Enterprise Knowledge Base v3.2] The core product is AI Gateway Test Platform, supporting unified access and quality verification for multi-vendor models such as OpenAI/Anthropic/Gemini. 1. Refund policy: unused member subscriptions fully refundable within 7 days; API quota refunded proportionally within 90 days; physical goods accepted within 15 days with 7-day no-reason return. ... (knowledge base long text truncated; original case is an enterprise KB of about 3600 chars repeated 3 times to trigger prompt caching)",
                        "role": "user"
                    }
                ],
                "model": "gpt-6-astra",
                "prompt_cache_options": {
                    "ttl": "30m"
                }
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            // Use ofInputStream to handle the streaming response
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) {
                            break;
                        }
                        // Tip: you can bring in Gson or Jackson here to parse the JSON in data and extract delta.content
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/openai/responses"

    jsonRequestBody := `
            {
                "input": [
                    {
                        "content": "[Enterprise Knowledge Base v3.2] The core product is AI Gateway Test Platform, supporting unified access and quality verification for multi-vendor models such as OpenAI/Anthropic/Gemini. 1. Refund policy: unused member subscriptions fully refundable within 7 days; API quota refunded proportionally within 90 days; physical goods accepted within 15 days with 7-day no-reason return. ... (knowledge base long text truncated; original case is an enterprise KB of about 3600 chars repeated 3 times to trigger prompt caching)",
                        "role": "user"
                    }
                ],
                "model": "gpt-6-astra",
                "prompt_cache_options": {
                    "ttl": "30m"
                }
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    // Pretty-print the returned JSON data
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

响应参数

Body 参数

参数名称	描述
id `string`	resp_ 开头的响应 ID
object `string`	固定为 response
model `string`	模型名
status `string`	completed
output `array`	输出数组，含 reasoning（加密）/ message / function_call
usage `object`	input_tokens / output_tokens 及推理明细
service_tier `string`	服务层级回带值