Refactor Conversations API to manage items instead of messages in README and implementation. Update methods and specs accordingly to reflect the new item structure.

Author: parterburn

README.md

@@ -1162,33 +1162,46 @@ To delete a conversation:
 response = client.conversations.delete(id: conversation_id)
 ```
 
-#### Managing Messages in Conversations
+#### Managing Items in Conversations
 
-You can add, retrieve, and manage messages within a conversation:
+You can add, retrieve, and manage items within a conversation.
 
-##### Creating a Message
+##### Creating Items
 
 ```ruby
-response = client.conversations.create_message(
+# Create multiple items at once
+response = client.conversations.create_items(
   conversation_id: conversation_id,
   parameters: {
-    content: "Hello! How can I help you today?",
-    role: "assistant",
-    metadata: { message_type: "greeting" }
+    items: [
+      {
+        type: "message",
+        role: "user",
+        content: [
+          { type: "input_text", text: "Hello!" }
+        ]
+      },
+      {
+        type: "message",
+        role: "assistant",
+        content: [
+          { type: "input_text", text: "How are you?" }
+        ]
+      }
+    ]
   }
 )
-message_id = response["id"]
 ```
 
-##### Listing Messages
+##### Listing Items
 
 ```ruby
-# List all messages in a conversation
-response = client.conversations.messages(conversation_id: conversation_id)
-messages = response["data"]
+# List all items in a conversation
+response = client.conversations.list_items(conversation_id: conversation_id)
+items = response["data"]
 
 # With parameters
-response = client.conversations.messages(
+response = client.conversations.list_items(
   conversation_id: conversation_id,
   parameters: { 
     limit: 10,
@@ -1197,21 +1210,21 @@ response = client.conversations.messages(
 )
 ```
 
-##### Retrieving a Specific Message
+##### Retrieving a Specific Item
 
 ```ruby
-message = client.conversations.retrieve_message(
+item = client.conversations.get_item(
   conversation_id: conversation_id,
-  message_id: message_id
+  item_id: item_id
 )
 ```
 
-##### Deleting a Message
+##### Deleting an Item
 
 ```ruby
-response = client.conversations.delete_message(
+response = client.conversations.delete_item(
   conversation_id: conversation_id,
-  message_id: message_id
+  item_id: item_id
 )
 ```
 

lib/openai/conversations.rb

@@ -24,21 +24,21 @@ def delete(id:)
       @client.delete(path: "/conversations/#{id}")
     end
 
-    # Message operations within a conversation
-    def messages(conversation_id:, parameters: {})
-      @client.get(path: "/conversations/#{conversation_id}/messages", parameters: parameters)
+    # Item operations within a conversation
+    def create_items(conversation_id:, parameters: {})
+      @client.json_post(path: "/conversations/#{conversation_id}/items", parameters: parameters)
     end
 
-    def retrieve_message(conversation_id:, message_id:)
-      @client.get(path: "/conversations/#{conversation_id}/messages/#{message_id}")
+    def list_items(conversation_id:, parameters: {})
+      @client.get(path: "/conversations/#{conversation_id}/items", parameters: parameters)
     end
 
-    def create_message(conversation_id:, parameters: {})
-      @client.json_post(path: "/conversations/#{conversation_id}/messages", parameters: parameters)
+    def get_item(conversation_id:, item_id:)
+      @client.get(path: "/conversations/#{conversation_id}/items/#{item_id}")
     end
 
-    def delete_message(conversation_id:, message_id:)
-      @client.delete(path: "/conversations/#{conversation_id}/messages/#{message_id}")
+    def delete_item(conversation_id:, item_id:)
+      @client.delete(path: "/conversations/#{conversation_id}/items/#{item_id}")
     end
   end
 end

spec/openai/client/conversations_spec.rb

@@ -5,11 +5,21 @@
         OpenAI::Client.new.conversations.create(parameters: {})["id"]
       end
     end
-    let(:message_id) do
-      VCR.use_cassette("#{cassette} message setup") do
-        OpenAI::Client.new.conversations.create_message(
+    let(:item_id) do
+      VCR.use_cassette("#{cassette} item setup") do
+        OpenAI::Client.new.conversations.create_items(
           conversation_id: conversation_id,
-          parameters: { content: "Hello, this is a test message" }
+          parameters: {
+            items: [
+              {
+                type: "message",
+                role: "user",
+                content: [
+                  { type: "input_text", text: "Hello, this is a test item" }
+                ]
+              }
+            ]
+          }
         )["id"]
       end
     end
@@ -104,13 +114,13 @@
       end
     end
 
-    describe "#messages" do
-      let(:cassette) { "conversations messages" }
+    describe "#list_items" do
+      let(:cassette) { "conversations list items" }
       let(:response) do
-        OpenAI::Client.new.conversations.messages(conversation_id: conversation_id)
+        OpenAI::Client.new.conversations.list_items(conversation_id: conversation_id)
       end
 
-      before { message_id }
+      before { item_id }
 
       it "succeeds" do
         VCR.use_cassette(cassette) do
@@ -120,7 +130,7 @@
 
       context "with parameters" do
         let(:response) do
-          OpenAI::Client.new.conversations.messages(
+          OpenAI::Client.new.conversations.list_items(
             conversation_id: conversation_id,
             parameters: { limit: 5 }
           )
@@ -134,68 +144,99 @@
       end
     end
 
-    describe "#retrieve_message" do
-      let(:cassette) { "conversations retrieve message" }
+    describe "#get_item" do
+      let(:cassette) { "conversations get item" }
       let(:response) do
-        OpenAI::Client.new.conversations.retrieve_message(
+        OpenAI::Client.new.conversations.get_item(
           conversation_id: conversation_id,
-          message_id: message_id
+          item_id: item_id
         )
       end
 
       it "succeeds" do
         VCR.use_cassette(cassette) do
-          expect(response["object"]).to eq("conversation.message")
+          expect(response["object"]).to eq("conversation.item")
         end
       end
     end
 
-    describe "#create_message" do
-      let(:cassette) { "conversations create message" }
+    describe "#create_items" do
+      let(:cassette) { "conversations create items" }
       let(:response) do
-        OpenAI::Client.new.conversations.create_message(
+        OpenAI::Client.new.conversations.create_items(
           conversation_id: conversation_id,
-          parameters: { content: "Hello, this is a test message" }
+          parameters: {
+            items: [
+              {
+                type: "message",
+                role: "user",
+                content: [
+                  { type: "input_text", text: "Hello!" }
+                ]
+              },
+              {
+                type: "message",
+                role: "assistant",
+                content: [
+                  { type: "input_text", text: "How are you?" }
+                ]
+              }
+            ]
+          }
         )
       end
 
       it "succeeds" do
         VCR.use_cassette(cassette) do
-          expect(response["object"]).to eq("conversation.message")
+          expect(response["object"]).to eq("conversation.item")
         end
       end
 
-      context "with additional parameters" do
+      context "with multiple items" do
         let(:response) do
-          OpenAI::Client.new.conversations.create_message(
+          OpenAI::Client.new.conversations.create_items(
             conversation_id: conversation_id,
             parameters: {
-              content: "Hello with metadata",
-              metadata: { test: "value" }
+              items: [
+                {
+                  type: "message",
+                  role: "user",
+                  content: [
+                    { type: "input_text", text: "Hello!" }
+                  ]
+                },
+                {
+                  type: "message",
+                  role: "user",
+                  content: [
+                    { type: "input_text", text: "How are you?" }
+                  ]
+                }
+              ]
             }
           )
         end
 
-        it "succeeds with additional parameters" do
+        it "succeeds with multiple items" do
           VCR.use_cassette(cassette) do
-            expect(response["object"]).to eq("conversation.message")
+            expect(response["object"]).to eq("conversation.item")
           end
         end
       end
     end
 
-    describe "#delete_message" do
-      let(:cassette) { "conversations delete message" }
+    describe "#delete_item" do
+      let(:cassette) { "conversations delete item" }
       let(:response) do
-        OpenAI::Client.new.conversations.delete_message(
+        OpenAI::Client.new.conversations.delete_item(
           conversation_id: conversation_id,
-          message_id: message_id
+          item_id: item_id
         )
       end
 
       it "succeeds" do
         VCR.use_cassette(cassette) do
-          expect(response["object"]).to eq("conversation.message.deleted")
+          expect(response["object"]).to eq("conversation.item.deleted")
         end
       end
     end