fix up the responses implementation

Author: leafo

openai/init.lua

@@ -52,6 +52,11 @@ do
     new_chat_session = function(self, ...)
       return ChatSession(self, ...)
     end,
+    new_response_chat_session = function(self, ...)
+      local ResponsesChatSession
+      ResponsesChatSession = require("openai.responses").ResponsesChatSession
+      return ResponsesChatSession(self, ...)
+    end,
     create_stream_filter = function(self, chunk_callback)
       assert(types["function"](chunk_callback), "Must provide chunk_callback function when streaming response")
       local accumulation_buffer = ""
@@ -171,6 +176,41 @@ do
     image_generation = function(self, params)
       return self:_request("POST", "/images/generations", params)
     end,
+    response = function(self, response_id)
+      assert(response_id, "response_id is required")
+      return self:_request("GET", "/responses/" .. tostring(response_id))
+    end,
+    delete_response = function(self, response_id)
+      assert(response_id, "response_id is required")
+      return self:_request("DELETE", "/responses/" .. tostring(response_id))
+    end,
+    cancel_response = function(self, response_id)
+      assert(response_id, "response_id is required")
+      return self:_request("POST", "/responses/" .. tostring(response_id) .. "/cancel")
+    end,
+    create_response = function(self, input, opts, stream_callback)
+      if opts == nil then
+        opts = { }
+      end
+      if stream_callback == nil then
+        stream_callback = nil
+      end
+      local create_response_stream_filter
+      create_response_stream_filter = require("openai.responses").create_response_stream_filter
+      local payload = {
+        input = input
+      }
+      if opts then
+        for k, v in pairs(opts) do
+          payload[k] = v
+        end
+      end
+      local stream_filter
+      if payload.stream and stream_callback then
+        stream_filter = create_response_stream_filter(stream_callback)
+      end
+      return self:_request("POST", "/responses", payload, nil, stream_filter)
+    end,
     _request = function(self, method, path, payload, more_headers, stream_fn)
       assert(path, "missing path")
       assert(method, "missing method")
@@ -250,18 +290,9 @@ do
   _base_0.__class = _class_0
   OpenAI = _class_0
 end
-local responses_methods, ResponseSession
-do
-  local _obj_0 = require("openai.responses")
-  responses_methods, ResponseSession = _obj_0.responses_methods, _obj_0.ResponseSession
-end
-for k, v in pairs(responses_methods) do
-  OpenAI.__base[k] = v
-end
 return {
   OpenAI = OpenAI,
   ChatSession = ChatSession,
-  ResponseSession = ResponseSession,
   VERSION = VERSION,
   new = OpenAI
 }

openai/init.moon

@@ -79,6 +79,10 @@ class OpenAI
   new_chat_session: (...) =>
     ChatSession @, ...
 
+  new_response_chat_session: (...) =>
+    import ResponsesChatSession from require "openai.responses"
+    ResponsesChatSession @, ...
+
   -- creates a ltn12 compatible filter function that will call chunk_callback
   -- for each parsed json chunk from the server-sent events api response
   create_stream_filter: (chunk_callback) =>
@@ -209,6 +213,41 @@ class OpenAI
   image_generation: (params) =>
     @_request "POST", "/images/generations", params
 
+  -- Get a stored response by ID
+  -- Returns: status, response, headers (raw result from _request)
+  response: (response_id) =>
+    assert response_id, "response_id is required"
+    @_request "GET", "/responses/#{response_id}"
+
+  -- Delete a stored response
+  delete_response: (response_id) =>
+    assert response_id, "response_id is required"
+    @_request "DELETE", "/responses/#{response_id}"
+
+  -- Cancel an in-progress streaming response
+  cancel_response: (response_id) =>
+    assert response_id, "response_id is required"
+    @_request "POST", "/responses/#{response_id}/cancel"
+
+  -- Create a single response (stateless)
+  -- input: string or array of message objects
+  -- opts: options like model, temperature, instructions, tools, etc.
+  -- stream_callback: optional function for streaming responses
+  -- Returns: status, response, headers (raw result from _request)
+  create_response: (input, opts={}, stream_callback=nil) =>
+    import create_response_stream_filter from require "openai.responses"
+
+    payload = { :input }
+
+    if opts
+      for k, v in pairs opts
+        payload[k] = v
+
+    stream_filter = if payload.stream and stream_callback
+      create_response_stream_filter stream_callback
+
+    @_request "POST", "/responses", payload, nil, stream_filter
+
   -- Responses API methods
   _request: (method, path, payload, more_headers, stream_fn) =>
     assert path, "missing path"
@@ -265,9 +304,5 @@ class OpenAI
 
     require @config.http_provider
 
-import responses_methods, ResponseSession from require "openai.responses"
-
-for k, v in pairs responses_methods
-  OpenAI.__base[k] = v
 
-{:OpenAI, :ChatSession, :ResponseSession, :VERSION, new: OpenAI}
+{:OpenAI, :ChatSession, :VERSION, new: OpenAI}

openai/responses.lua

@@ -1,6 +1,7 @@
 local cjson = require("cjson")
 local types
 types = require("tableshape").types
+local DEFAULT_RESPONSES_MODEL = "gpt-4.1-mini"
 local empty = (types["nil"] + types.literal(cjson.null)):describe("nullable")
 local input_format = types.string + types.array_of(types.partial({
   role = types.one_of({
@@ -43,8 +44,7 @@ local parse_responses_response = types.partial({
   output = types.array_of(response_message):tag("output"),
   model = empty + types.string:tag("model"),
   usage = empty + types.table:tag("usage"),
-  stop_reason = empty + types.string:tag("stop_reason"),
-  stop_sequence = empty + (types.string + empty):tag("stop_sequence")
+  status = empty + types.string:tag("status")
 })
 local parse_response_stream_chunk
 parse_response_stream_chunk = function(chunk)
@@ -160,7 +160,7 @@ create_response_stream_filter = function(chunk_callback)
     return ...
   end
 end
-local ResponseSession
+local ResponsesChatSession
 do
   local _class_0
   local _base_0 = {
@@ -182,23 +182,26 @@ do
       end
       assert(input, "input must be provided")
       assert(input_format(input))
-      local payload = {
-        model = self.opts.model or "gpt-4.1-mini",
-        input = input
+      local merged_opts = {
+        model = self.opts.model,
+        previous_response_id = self.current_response_id
       }
       if self.opts.instructions then
-        payload.instructions = self.opts.instructions
+        merged_opts.instructions = self.opts.instructions
       end
       if opts then
         for k, v in pairs(opts) do
-          payload[k] = v
+          merged_opts[k] = v
         end
       end
+      if stream_callback then
+        merged_opts.stream = merged_opts.stream or true
+      end
       local accumulated_text = { }
       local final_response = nil
-      local stream_filter
-      if payload.stream then
-        stream_filter = create_response_stream_filter(function(chunk)
+      local wrapped_callback
+      if merged_opts.stream then
+        wrapped_callback = function(chunk)
           if chunk.text_delta then
             table.insert(accumulated_text, chunk.text_delta)
           end
@@ -209,21 +212,18 @@ do
           if stream_callback then
             return stream_callback(chunk)
           end
-        end)
+        end
       end
-      local status, response = self.client:_request("POST", "/responses", payload, nil, stream_filter)
+      local status, response = self.client:create_response(input, merged_opts, wrapped_callback)
       if status ~= 200 then
         return nil, "Request failed with status: " .. tostring(status), response
       end
-      if payload.stream then
-        local text_out = table.concat(accumulated_text)
+      if merged_opts.stream then
         if final_response then
           self.current_response_id = final_response.id
           table.insert(self.response_history, final_response)
-        elseif text_out ~= "" then
-          self.current_response_id = "stream_" .. tostring(os.time())
         end
-        return text_out
+        return table.concat(accumulated_text)
       end
       local parsed_response, err = parse_responses_response(response)
       if not (parsed_response) then
@@ -246,7 +246,7 @@ do
       self.current_response_id = self.opts.previous_response_id
     end,
     __base = _base_0,
-    __name = "ResponseSession"
+    __name = "ResponsesChatSession"
   }, {
     __index = _base_0,
     __call = function(cls, ...)
@@ -256,70 +256,13 @@ do
     end
   })
   _base_0.__class = _class_0
-  ResponseSession = _class_0
+  ResponsesChatSession = _class_0
 end
-local responses_methods = {
-  new_response_session = function(self, ...)
-    return ResponseSession(self, ...)
-  end,
-  create_response = function(self, input, opts, stream_callback)
-    if opts == nil then
-      opts = { }
-    end
-    if stream_callback == nil then
-      stream_callback = nil
-    end
-    assert(input, "input must be provided")
-    assert(input_format(input))
-    local payload = {
-      model = "gpt-4.1-mini",
-      input = input
-    }
-    if opts then
-      for k, v in pairs(opts) do
-        payload[k] = v
-      end
-    end
-    local accumulated_text = { }
-    local final_response = nil
-    local stream_filter
-    if payload.stream then
-      stream_filter = create_response_stream_filter(function(chunk)
-        if chunk.text_delta then
-          table.insert(accumulated_text, chunk.text_delta)
-        end
-        if chunk.response then
-          final_response = add_response_helpers(chunk.response)
-          chunk.response = final_response
-        end
-        if stream_callback then
-          return stream_callback(chunk)
-        end
-      end)
-    end
-    local status, response = self:_request("POST", "/responses", payload, nil, stream_filter)
-    if status ~= 200 then
-      return nil, "Request failed with status: " .. tostring(status), response
-    end
-    if payload.stream then
-      if final_response then
-        add_response_helpers(final_response)
-      end
-      return table.concat(accumulated_text)
-    end
-    local parsed_response, err = parse_responses_response(response)
-    if not (parsed_response) then
-      return nil, "Failed to parse response: " .. tostring(err), response
-    end
-    add_response_helpers(parsed_response)
-    return parsed_response
-  end
-}
 return {
-  ResponseSession = ResponseSession,
-  responses_methods = responses_methods,
+  ResponsesChatSession = ResponsesChatSession,
   parse_responses_response = parse_responses_response,
   parse_response_stream_chunk = parse_response_stream_chunk,
+  create_response_stream_filter = create_response_stream_filter,
   add_response_helpers = add_response_helpers,
   extract_output_text = extract_output_text
 }