I know the original comment is about using Claude Code to develop the code base, but I’m wondering if Responses are exclusively an OpenAI thing.
I was under the impression that, say, Claude’s API was compatible with OpenAI’s API, but maybe that is not true for Responses.
I’d just rather give money to Anthropic than OpenAI if paying for credits outside of my Claude Max subscription for Claude Code usage.
OpenAI.Responses is indeed OpenAI-only library, but I develop it using Claude Code, which I think is the current SOTA in terms of the code generation quality.
openai_responses library has been updated to v0.4.0. This release cleans up both the API and implementation details, and adds improved support for streaming (including streaming JSON events) , structured outputs, and function calling. Additional details can be found in Changelog for v0.4.0.
Here are some examples of using the new API from the Livebook Tutorial:
alias OpenAI.Responses
Responses.create!(
input: [
%{role: :developer, content: "Talk like a pirate."},
%{role: :user, content: "Write me a haiku about Elixir"}
]
)
|> Responses.create!(input: "Which programming language is this haiku about?")
|> Map.get(:text)
|> IO.puts()
# Output contains "Elixir"; still talks like a pirate
{:ok, response} = Responses.create("Explain quantum computing")
# All cost values are Decimal for precision
IO.inspect(response.cost)
# => %{
# input_cost: #Decimal<0.0004>,
# output_cost: #Decimal<0.0008>,
# total_cost: #Decimal<0.0012>,
# cached_discount: #Decimal<0>
# }
Responses.stream(
input: "List 3 programming languages with their year of creation",
model: "gpt-4o-mini",
schema: %{
languages: {:array, %{
name: :string,
year: :integer,
paradigm: {:string, description: "Main programming paradigm"}
}}
}
)
|> Responses.Stream.json_events()
|> Enum.each(&IO.puts/1)
run/2 instead of create/1):# Define available functions
functions = %{
"get_weather" => fn %{"location" => location} ->
# In a real app, this would call a weather API
case location do
"Paris" -> "15°C, partly cloudy"
"London" -> "12°C, rainy"
"New York" -> "8°C, sunny"
_ -> "Weather data not available"
end
end,
"get_time" => fn %{"timezone" => timezone} ->
# In a real app, this would get actual time for timezone
case timezone do
"Europe/Paris" -> "14:30"
"Europe/London" -> "13:30"
"America/New_York" -> "08:30"
_ -> "Unknown timezone"
end
end
}
# Define function tools
weather_tool = Responses.Schema.build_function(
"get_weather",
"Get current weather for a location",
%{location: {:string, description: "City name"}}
)
time_tool = Responses.Schema.build_function(
"get_time",
"Get current time in a timezone",
%{timezone: {:string, description: "Timezone like Europe/Paris"}}
)
# Run the conversation with automatic function calling
responses = Responses.run(
[
input: "What's the weather and time in Paris?",
tools: [weather_tool, time_tool]
],
functions
)
openai_responses library has been updated to v0.5.1, bringing significant enhancements since v0.4.0. This release adds union type support, manual function calling control, built-in error handling with retry logic, and flexible API options. See the full changelog for complete details.
anyOfDefine properties that can be multiple types:
alias OpenAI.Responses
Responses.create!(
input: "Generate a product listing",
schema: %{
price: {:anyOf, [:number, :string]}, # Can be 29.99 or "$29.99"
tags: {:anyOf, [:string, {:array, :string}]} # Can be "electronics" or ["laptop", "gaming"]
}
)
Take control of function execution with the new call_functions/2:
# Get a response with function calls
{:ok, response} = Responses.create(
input: "What's the weather in Paris and London?",
tools: [weather_tool]
)
# Manually execute functions with custom logic
outputs = Responses.call_functions(response.function_calls, %{
"get_weather" => fn %{"location" => city} ->
# Add logging, caching, or modify results
Logger.info("Weather requested for #{city}")
weather = fetch_weather_from_api(city)
%{temperature: weather.temp, conditions: weather.desc, cached_at: DateTime.utc_now()}
end
})
# Continue conversation with enriched results
{:ok, final} = Responses.create(response, input: outputs)
The new OpenAI.Responses.Error module provides intelligent error handling:
case Responses.create(input: "Hello") do
{:ok, response} ->
IO.puts(response.text)
{:error, error} ->
if OpenAI.Responses.Error.retryable?(error) do
# Retry with exponential backoff for 429, 500, 503, or timeout errors
:timer.sleep(1000)
# retry the request
else
# Handle non-retryable errors
Logger.error("API error: #{error.message}")
end
end
All major functions now accept both keyword lists and maps:
# Traditional keyword list
Responses.create(input: "Hello", model: "gpt-4o", temperature: 0.7)
# Using maps (great for dynamic options)
options = %{input: "Hello", model: "gpt-4o", temperature: 0.7}
Responses.create(options)
# Works with streaming too
Responses.stream(%{
input: "Write a story",
stream: Responses.Stream.delta(&IO.write/1)
})
The API remains backward compatible while providing more flexibility and control over your AI interactions.
Hi everyone! I’m excited to announce the release of OpenAI.Responses 0.6.0, which includes several improvements and bug fixes since version 0.5.1.
The biggest feature in this release is automatic support for arrays at the root level of structured output schemas. Previously, OpenAI’s API required the root level to be an object, which meant you had to manually wrap arrays. Now the library handles this transparently:
# You can now do this directly!
{:ok, response} = Responses.create(
input: "List 3 interesting facts about space exploration",
schema: {:array, %{
fact: :string,
year: {:integer, description: "Year of the event"},
significance: {:string, description: "Why this fact is important"}
}}
)
# response.parsed is an array directly:
[
%{"fact" => "First satellite launch", "year" => 1957, "significance" => "Started the space age"},
%{"fact" => "Moon landing", "year" => 1969, "significance" => "First humans on another celestial body"},
%{"fact" => "ISS construction", "year" => 1998, "significance" => "Permanent human presence in space"}
]
The library automatically wraps arrays in an object before sending to the API and unwraps them in the response, making the developer experience seamless.
Duplicate Assistant Response Handling (0.5.3)
Fixed an edge case where the OpenAI API sometimes returns duplicate assistant responses. The library now only processes the first assistant response in Response.extract_text/1, preventing duplicate content in your results.
:schema optionTo upgrade to the latest version, update your mix.exs:
def deps do
[
{:openai_responses, "~> 0.6.0"}
]
end
Then run:
mix deps.update openai_responses