instruct 0.1.0a1

data/lib/instruct/gen/gen.rb

@@ -0,0 +1,70 @@
+module Instruct
+ class Gen
+   include Instruct::Serializable
+   set_instruct_class_id 2
+
+   attr_accessor :prompt, :model, :gen_kwargs
+   attr_accessor :capture_key, :capture_list_key
+   attr_reader :results
+   def initialize(prompt:, model:, **kwargs)
+     @prompt = prompt
+     @model = model
+     @gen_kwargs = kwargs
+     @results = []
+     @capture_key = nil
+     @capture_list_key = nil
+   end
+
+
+   def ==(other)
+     return false unless other.is_a?(Gen)
+     # skip looking at prompt and results for now as it makes two prompts not equal with a gen
+     # that has run and one that hasn't
+     return false if @gen_kwargs != other.gen_kwargs
+     return false if @model.is_a?(String) && other.model.is_a?(String) && @model != other.model
+     return @model.class == other.model.class
+   end
+
+   def capture(key, list: nil)
+     @capture_key, @capture_list_key = key, list
+     self
+   end
+
+   def completed?
+     @results.any?
+   end
+
+   # This is the method that actually calls the LLM API with the prompt and creates a completion
+   # @param model this is a model object or the name of a model.
+   # @param client_opts: this is an optional hash of options to pass to the API client when initializing a client model with a string
+   # @block streaming_block: this is an optional block that will be called with each chunk of the response when the response is streamed
+   def call(model: nil, **call_kwargs, &streaming_block)
+     gen_and_call_kwargs = gen_kwargs.merge(call_kwargs)
+     model = select_first_model_from(model, @model, Instruct.default_model, gen_and_call_kwargs:)
+
+     generate_completion = Instruct::GenerateCompletion.new(prompt:, model:, capture_key:, capture_list_key:, streaming_block:, gen_and_call_kwargs: )
+     completion = generate_completion.call(calling_gen: self)
+
+     @results << completion
+     completion
+   end
+
+
+   def to_s
+     if @result.nil?
+       "<Instruct::Gen>"
+     else
+        "<Instruct::Gen call_count=#{result.length}>"
+     end
+   end
+
+   private
+
+   def select_first_model_from(*args, gen_and_call_kwargs:)
+     model = args.compact.first
+     model = Instruct::Model.from_string(model, **gen_and_call_kwargs) if model.is_a?(String)
+     model
+   end
+
+ end
+end

data/lib/instruct/gen/generate_completion.rb

@@ -0,0 +1,61 @@
+module Instruct
+  class GenerateCompletion
+    def initialize(prompt:, model:, streaming_block:nil, capture_key:, capture_list_key:, gen_and_call_kwargs:)
+      @prompt = prompt
+      @model = model
+      @streaming_block = streaming_block
+      @capture_key = capture_key
+      @capture_list_key = capture_list_key
+      @gen_and_call_kwargs = gen_and_call_kwargs
+      @run = false
+    end
+
+    def call(calling_gen:)
+      raise RuntimeError, "Cannot call a completed Gen" if @run
+      @run = true
+
+      @original_prompt = @prompt.dup
+      completion = Prompt::Completion.new
+      prompt = prompt_with_gen_attachment_removed(calling_gen)
+      @request = Gen::CompletionRequest.new(prompt: prompt, completion: completion, env: build_request_env)
+      if @streaming_block
+        @request.add_stream_handler do |response|
+          response = prepare_completion_for_return(response)
+          @streaming_block.call(response)
+        end
+      end
+      middleware = build_model_middleware_chain(@request)
+      response = middleware.execute(@request)
+      completion = response.attributed_string
+      prepare_completion_for_return(completion)
+    end
+
+    private
+
+    def prepare_completion_for_return(completion)
+      completion._prepare_for_return(prompt: @original_prompt, captured_key: @capture_key, captured_list_key: @capture_list_key, updated_prompt: @request.prompt)
+      completion
+    end
+
+    def build_request_env
+      @model.default_request_env.merge(@gen_and_call_kwargs)
+    end
+
+    def build_model_middleware_chain(request)
+      if @model.respond_to?(:middleware_chain)
+        @model.middleware_chain(request)
+      else
+        @model
+      end
+    end
+
+    def prompt_with_gen_attachment_removed(calling_gen)
+      if calling_gen && @prompt.attachment_at(@prompt.length - 1) == calling_gen
+        @prompt[...-1]
+      else
+        @prompt.dup
+      end
+    end
+
+  end
+end

data/lib/instruct/helpers/erb_helper.rb

@@ -0,0 +1,29 @@
+module Instruct
+  module Helpers
+    P_HELPER_ERROR_MESSAGE = "the p(rompt) helpers should be called using a block p{<arg>} not p(<arg>)"
+    module ERBHelper
+      def p(*args, &block)
+        raise ArgumentError, P_HELPER_ERROR_MESSAGE if args.length > 0
+        if block_given?
+          Instruct::CompileERB.new(template: yield, _binding: block.binding).prompt
+        else
+          P.new
+        end
+      end
+    end
+    class P
+      def system(*args, &block)
+        raise ArgumentError, P_HELPER_ERROR_MESSAGE if args.length > 0
+        return Prompt.new("\nsystem: ", safe: true)+ Instruct::CompileERB.new(template: yield, _binding: block.binding).prompt
+      end
+      def user(*args, &block)
+        raise ArgumentError, P_HELPER_ERROR_MESSAGE if args.length > 0
+        return Prompt.new("\nuser: ", safe: true) + Instruct::CompileERB.new(template: yield, _binding: block.binding).prompt
+      end
+      def assistant(*args, &block)
+        raise ArgumentError, P_HELPER_ERROR_MESSAGE if args.length > 0
+        return Prompt.new("\nassistant: ", safe: true) + Instruct::CompileERB.new(template: yield, _binding: block.binding).prompt
+      end
+    end
+  end
+end

data/lib/instruct/helpers/gen_helper.rb

@@ -0,0 +1,22 @@
+module Instruct::Helpers
+  module GenHelper
+    # This helper is used to create a new Instruct::Gen object. It can be used in
+    # two ways: with a prompt or without. If a prompt is provided, the
+    # method will immediately return the generated completion. If no prompt
+    # is provided, the method will return a deferred completion that can be
+    # appended to a prompt.
+    # @param prompt [Instruct::Prompt, String, nil] The prompt to generate a completion for.
+    # @param model [Instruct::Model, String, nil] The model to use for generation.
+    # @param client_opts [Hash] Optional keyword argument that contains an option hash to pass to the API client when initializing a client model with a string.
+    def gen(prompt = nil, model: nil, **kwargs)
+
+      prompt = Instruct::Prompt.new(prompt) if prompt.class == String
+      model ||= self.respond_to?(:instruct_default_model) ? self.instruct_default_model : nil
+      gen = Instruct::Gen.new(prompt: , model: , **kwargs)
+
+      return gen.call if prompt
+
+      Instruct::Prompt.new.add_attachment(gen)
+    end
+  end
+end

data/lib/instruct/helpers/helpers.rb

@@ -0,0 +1,9 @@
+module Instruct
+  module Helpers
+    include Instruct::Helpers::GenHelper
+    include Instruct::Helpers::ERBHelper
+    include Instruct::Helpers::ModelHelper
+
+
+  end
+end

data/lib/instruct/helpers/model_helper.rb

@@ -0,0 +1,13 @@
+module Instruct::Helpers
+ module ModelHelper
+
+   def instruct_default_model
+     @_instruct_default_model ||= Instruct.default_model
+   end
+
+   def instruct_default_model=(string_or_model)
+     @_instruct_default_model = Instruct::Model.from_string_or_model(string_or_model)
+   end
+
+ end
+end

data/lib/instruct/helpers/refinements.rb

@@ -0,0 +1,54 @@
+module Instruct
+  module Refinements
+    refine String do
+      # alias_method :old_double_arrow, :<<
+      # private :old_double_arrow
+      def <<(other)
+        if other.is_a?(Prompt) || other.is_a?(Prompt::Completion)
+        raise Instruct::Error, <<~ERR.chomp
+          Consider using become gem here to make string become a prompt, if you see this error you should
+          convert your string to an Instruct::Prompt either using Instruct::Prompt.new or "safe string".prompt_safe
+          ERR
+        else
+          super
+        end
+      end
+        # alias_method :instruct_old_plus, :+
+        # private :instruct_old_plus
+
+        def +(other)
+          if other.is_a?(Prompt) || other.is_a?(Prompt::Completion)
+            Prompt.new(self) + other
+          else
+            super
+          end
+        end
+
+        def prompt_safe
+          string = self.is_a?(AttributedString) ? self : Prompt.new(self)
+          string.add_attrs(safe: true)
+        end
+    end
+    #   alias_method :instruct_old_plus, :+
+    #   private :instruct_old_plus
+
+    #   def +(other)
+    #     if other.is_a?(Instruct::Expression::Expression)
+    #       wrapped = Instruct::Expression::PlainText.new(self)
+    #       Instruct::Expression::Concat.new(wrapped, other)
+    #     else
+    #       instruct_old_plus(other)
+    #     end
+    #   end
+
+    # end
+    # refine Object do
+    #   def erb(safe: nil, &block)
+    #     Instruct::Expression::ERBFuture.new(template: block.call, binding: block.binding, safe:)
+    #   end
+    #   def gen(**kwargs)
+    #     Instruct::Expression::LLMFuture.new(**kwargs)
+    #   end
+    # end
+  end
+end

data/lib/instruct/llms/anthropic/completion_model.rb

@@ -0,0 +1,107 @@
+module Instruct
+  class Anthropic
+    include Instruct::Serializable
+    set_instruct_class_id 200
+
+    # params client_or_model_name [Anthropic::Client, String] Client instance or model name string
+    # params model [String] Required model name to use for completion if client is provided as first arg
+    attr_reader :default_request_env
+    def initialize(client_or_model_name = "claude-3-5-sonnet-latest", middlewares: [], **kwargs)
+      @middlewares = middlewares
+      @default_request_env = kwargs
+      @cached_clients = {}
+
+      if client_or_model_name.is_a? ::Anthropic::Client
+        @client = client_or_model_name
+        @model_name = kwargs.delete(:model) if kwargs[:model]
+        raise ArgumentError, "model: keyword argument must be a model name string when initializing with a client (see https://docs.anthropic.com/claude/docs/models-overview)" if @model_name.nil? || @model_name.empty?
+      elsif client_or_model_name.is_a? String
+        @model_name = client_or_model_name if client_or_model_name.is_a? String
+        raise ArgumentError, "Model name must not be blank (see https://docs.anthropic.com/claude/docs/models-overview)" if @model_name.empty?
+      else
+        raise ArgumentError, "arg must be a model name string (see https://docs.anthropic.com/claude/docs/models-overview) or an instance of Anthropic::Client"
+      end
+
+      append_default_middleware_if_not_added
+      set_access_token_from_env_if_needed
+    end
+
+    def middleware_chain(req)
+      @middleware_chain ||= Instruct::MiddlewareChain.new(middlewares: (@middlewares || []) << self)
+    end
+
+    def call(req, _next:)
+      client = build_client(req.env[:anthropic_client_opts])
+      messages_params = req.env[:anthropic_messages_opts]||{}
+      messages_params[:model] = @model_name if messages_params[:model].nil?
+      warn_about_latest_model_if_needed(messages_params[:model])
+      messages_params[:max_tokens] ||= max_tokens_if_not_set(messages_params[:model])
+      messages_params.merge!(req.prompt_object)
+
+      response = Instruct::Anthropic::MessagesCompletionResponse.new(**req.response_kwargs)
+      messages_params[:stream] = Proc.new { |chunk| response.call(chunk) }
+
+      begin
+        Instruct.logger.info("Sending Anthropic Messages Completion Request: (#{request_params}) Client:(#{client.inspect})") if Instruct.logger.sev_threshold <= Logger::INFO
+        _client_response = client.messages(parameters: messages_params)
+      rescue Faraday::Error => e
+        if e.respond_to?(:response_body)
+          Instruct.err_logger.error("#{e.response_body}")
+        else
+          Instruct.err_logger.error("#{e.inspect}")
+        end
+        raise e
+      end
+
+      response
+    end
+
+    def max_tokens_if_not_set(model_name)
+      if model_name.include?("claude-3-5-sonnet")
+        8192
+      else
+        4096
+      end
+    end
+
+    @@warned_about_latest_model = false
+    def self.warned_about_latest_model?
+      @@warned_about_latest_model
+    end
+
+
+    protected
+
+    def append_default_middleware_if_not_added
+      [Instruct::ChompMiddleware, Instruct::ChatCompletionMiddleware, Instruct::Anthropic::Middleware].each do |middleware|
+        if !@middlewares.any? { |m| m.is_a?(middleware) }
+          @middlewares << middleware.new
+        end
+      end
+    end
+
+    private
+
+    def build_client(req_client_opts = {})
+      if @client
+        raise ArgumentError, "Client options must not be set when initializing with a client" if req_client_opts.any?
+        return @client
+      end
+
+      @cached_clients[req_client_opts.hash] ||=  ::Anthropic::Client.new(req_client_opts)
+    end
+
+
+    def set_access_token_from_env_if_needed
+      access_key = ENV["ANTHROPIC_ACCESS_TOKEN"] || ENV["ANTHROPIC_API_KEY"]
+      @default_request_env[:access_token] = access_key if access_key && @default_request_env[:access_token].nil?
+    end
+
+    def warn_about_latest_model_if_needed(model_name)
+      return if Instruct.suppress_warnings
+      if model_name.end_with?("latest") && !@@warned_about_latest_model
+        puts "Warning: You are using an anthropic model with the 'latest' suffix. This is alright for development, but not recommended for production. See https://docs.anthropic.com/en/docs/about-claude/models for more information."
+      end
+    end
+  end
+end

data/lib/instruct/llms/anthropic/messages_completion_response.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Instruct::Anthropic
+  class MessagesCompletionResponse < Instruct::Gen::CompletionResponse
+    @delta_finish_reason = nil
+
+    def call(chunk)
+      chunk = Instruct::SymbolizeKeys.recursive(chunk)
+      case chunk
+      in { type: "message_start" }
+        # do nothing
+      in { type: "content_block_start", index: _index, content_block: { type: "text", text: chunk }}
+          append_text_chunk(chunk)
+      in { type: "content_block_delta", index: _index, delta: { type: "text_delta", text: chunk }}
+          append_text_chunk(chunk)
+      in { type: "content_block_stop", index: _index }
+          # do nothing
+      in { type: "message_delta", delta: { stop_reason: } }
+          # this occurs just before the message_stop and lets us collect the stop reason (and other info like output tokens)
+          @delta_finish_reason = stop_reason
+      in { type: "message_stop" }
+        done(@delta_finish_reason)
+      in { type: "ping" }
+        # do nothing
+      in { error: { message: , type: } }
+        raise RuntimeError, "Anthropic Client Error: (type: #{type}, message: #{message})"
+      else
+        raise RuntimeError, "Unexpected Chunk: #{chunk}"
+      end
+      chunk_processed
+    end
+
+
+  end
+end

data/lib/instruct/llms/anthropic/middleware.rb

@@ -0,0 +1,91 @@
+class Instruct::Anthropic
+  class Middleware
+    include Instruct::Serializable
+    set_instruct_class_id 201
+
+    CLIENT_PARAMS = %i[access_token anthropic_version api_version extra_headers request_timeout uri_base beta].freeze
+    # TODO: make request params settable at the model level, its silly to not set temperature in one place
+    REQUEST_PARAMS = %i[metadata max_tokens temperature tools tool_choice top_k top_p stop_sequences system].freeze
+
+    def call(req, _next:)
+      raise Instruct::Todo, "Tools are not supported yet, consider opening a pull request" if req.env[:tools] || req.env[:tool_choice]
+
+      # pull out the client options that were in the call and put them in anthropic_client_opts
+      client_options = filter_env_keys(req, CLIENT_PARAMS)
+      transform_beta_argument_into_extra_headers(client_options, req.env[:beta])
+
+      req.env[:anthropic_client_opts] = client_options
+
+      # pull out the message request params and put them in anthropic_messages_opts
+      request_options = filter_env_keys(req, REQUEST_PARAMS)
+      if request_options[:system].nil?
+        # TODO: this will probably go back into the chat completion middleware and can be removed
+        request_options[:system] = req.env[:system_from_prompt].to_s
+      end
+      normalize_stop_sequence_arguments(req, request_options)
+
+      req.env[:anthropic_messages_opts] = request_options
+
+      req.add_prompt_transform do | prompt_obj |
+        transform(prompt_obj)
+      end
+
+      _next.call(req)
+    end
+
+    private
+
+    def filter_env_keys(req, keys)
+      req.env.select { |k, _| keys.include?(k) }
+    end
+
+    def normalize_stop_sequence_arguments(req, request_options)
+      # Make the stop_chars and stop options consistent with openai
+      if req.env[:stop_chars].is_a?(String)
+        request_options[:stop_sequences] = req.env[:stop_chars].split('')
+      end
+      if req.env[:stop].is_a?(String)
+        request_options[:stop_sequences] = [req.env[:stop]]
+      elsif req.env[:stop].is_a?(Array)
+        request_options[:stop_sequences] = req.env[:stop]
+      end
+    end
+
+    def transform(prompt_obj)
+      raise RuntimeError, "Expected hash with messages, probably missing chat completion middleware" unless prompt_obj.is_a?(Hash) && prompt_obj[:messages].is_a?(Array)
+      remove_system_message(prompt_obj)
+      convert_messages_to_anthropic_format(prompt_obj)
+      prompt_obj
+    end
+
+    def remove_system_message(prompt_obj)
+      prompt_obj[:messages].reject! { |message| message.keys.first == :system }
+    end
+
+    def convert_messages_to_anthropic_format(prompt_obj)
+      prompt_obj[:messages].map! do |message|
+        { role: message.keys.first, content: message.values.first.to_s }
+      end
+    end
+
+    # This method takes the beta argument and transforms it into a header for the client
+    def transform_beta_argument_into_extra_headers(client_options, beta)
+      return unless beta
+      client_options.delete(:beta)
+      client_options[:extra_headers] ||= {}
+
+      if client_options[:extra_headers]['anthropic-beta']
+        raise ArgumentError, "Cannot set anthropic-beta header to #{beta} when it is already set to #{client_options[:extra_headers]['anthropic-beta']}."
+      end
+
+      if beta.is_a?(Array)
+        client_options[:extra_headers]['anthropic-beta'] = beta.join(',')
+      elsif beta.is_a?(String)
+        client_options[:extra_headers] ||= {}
+        client_options[:extra_headers]['anthropic-beta'] = beta.to_s
+      else
+        raise ArgumentError, "beta must be a string or an array of strings"
+      end
+    end
+  end
+end

data/lib/instruct/llms/openai/chat_completion_response.rb

@@ -0,0 +1,21 @@
+class Instruct::OpenAI
+  class ChatCompletionResponse < Instruct::Gen::CompletionResponse
+
+    def call(chunk)
+      case Instruct::SymbolizeKeys.recursive(chunk)
+      # TODO: check if this will break if the content is not text
+      in { choices: [ { delta: {}, finish_reason: } ] }
+        done(finish_reason) unless finish_reason.nil?
+      in { choices: [ { delta: { content: new_content }, finish_reason: } ] }
+        append_text_chunk(new_content)
+        done(finish_reason) unless finish_reason.nil?
+      in { error: { message: } }
+        raise RuntimeError, "OpenAI Client Error: #{message}"
+      else
+        raise RuntimeError, "Unexpected Chunk: #{chunk}"
+      end
+      chunk_processed
+    end
+
+  end
+end

data/lib/instruct/llms/openai/completion_model.rb

@@ -0,0 +1,129 @@
+module Instruct
+  class OpenAI
+    include Instruct::Serializable
+    set_instruct_class_id 100
+
+    attr_reader :default_request_env
+
+    def middleware_chain(req)
+      middlewares = @middlewares || []
+      append_default_middleware_if_not_added(req, middlewares)
+      @middleware_chain ||= Instruct::MiddlewareChain.new(middlewares: (middlewares << self))
+    end
+
+    def initialize(client_or_model_name = 'gpt-3.5-turbo-instruct', middlewares: [], **kwargs)
+      @middlewares = middlewares
+      @default_request_env = kwargs
+      @cached_clients = {}
+
+      if client_or_model_name.is_a? ::OpenAI::Client
+        @client = client_or_model_name
+        @model_name = kwargs.delete(:model) if kwargs[:model]
+        raise ArgumentError, "model: keyword argument must be a model name string when initializing with a client" if @model_name.nil? || @model_name.empty?
+      elsif client_or_model_name.is_a? String
+        @model_name = client_or_model_name
+        raise ArgumentError, "Model name must not be blank" if @model_name.empty?
+      else
+        raise ArgumentError, "arg must be a model name string or an instance of OpenAI::Client"
+      end
+
+      set_access_token_from_env_if_needed
+    end
+
+    def call(req, _next:)
+      client = build_client(req.env[:openai_client_opts] || {})
+
+      request_params = req.env[:openai_args] || {}
+      request_params[:model] = @model_name if request_params[:model].nil?
+
+      if is_chat_model?(req)
+        response = request_params[:stream] = Instruct::OpenAI::ChatCompletionResponse.new(**req.response_kwargs)
+        request_params.merge!(req.prompt_object)
+        warn_about_deprecated_args(req.env[:openai_deprecated_args]) if req.env[:openai_deprecated_args]
+        begin
+          Instruct.logger.info("Sending OpenAI Chat Completion Request: (#{request_params}) Client:(#{client.inspect})") if Instruct.logger.sev_threshold <= Logger::INFO
+          _client_response = client.chat(parameters: request_params)
+        rescue Faraday::Error => e
+          if e.respond_to?(:response_body)
+            Instruct.err_logger.error("#{e.response_body}")
+          else
+            Instruct.err_logger.error("#{e.inspect}")
+          end
+          raise e
+        end
+      else
+        warn_about_completions_endpoint if !@warned
+        response = request_params[:stream] = Instruct::OpenAI::CompletionResponse.new(**req.response_kwargs)
+        request_params.merge!({prompt: req.prompt_object})
+        begin
+            Instruct.logger.info("Sending OpenAI Completion Request: (#{request_params}) Client:(#{client.inspect})") if Instruct.logger.sev_threshold <= Logger::INFO
+          _client_response = client.completions(parameters: request_params)
+        rescue Faraday::Error => e
+          if e.respond_to?(:response_body)
+            Instruct.err_logger.error("#{e.response_body}")
+          else
+            Instruct.err_logger.error("#{e.inspect}")
+          end
+          raise e
+        end
+      end
+      response
+    end
+
+    protected
+
+    def append_default_middleware_if_not_added(req, middlewares)
+      openai_middlewares = [Instruct::OpenAI::Middleware.new]
+      if is_chat_model?(req)
+        openai_middlewares = [Instruct::ChompMiddleware.new, Instruct::ChatCompletionMiddleware.new] + openai_middlewares
+      end
+      openai_middlewares.each do |middleware|
+        if !middlewares.any? { |m| m.is_a?(middleware.class) }
+          middlewares << middleware
+        end
+      end
+    end
+
+    private
+
+    def is_chat_model?(req)
+      !(req.env[:use_completion_endpoint] || ((req.env[:model] || @model_name) == 'gpt-3.5-turbo-instruct'))
+    end
+
+    def build_client(req_client_opts = {})
+      if @client
+        raise ArgumentError, "Client options must not be set when initializing with a client" if req_client_opts.any?
+        return @client
+      end
+
+      client_opts = @default_request_env.select { |k, _| Instruct::OpenAI::Middleware::CLIENT_PARAMS.include?(k) }
+      client_opts.merge!(req_client_opts)
+
+      @cached_clients[client_opts.hash] ||= ::OpenAI::Client.new(
+        access_token: client_opts[:access_token] || ENV['OPENAI_API_KEY'] || ENV['OPENAI_ACCESS_TOKEN'],
+        uri_base: client_opts[:uri_base],
+        request_timeout: client_opts[:request_timeout],
+        extra_headers: client_opts[:extra_headers]
+      )
+    end
+
+    def set_access_token_from_env_if_needed
+      access_key = ENV['OPENAI_API_KEY'] || ENV['OPENAI_ACCESS_TOKEN']
+      @default_request_env[:access_token] = access_key if access_key && @default_request_env[:access_token].nil?
+    end
+
+    def warn_about_deprecated_args(deprecated_args)
+      return if Instruct.suppress_warnings || @deprecated_arg_warned
+      if deprecated_args && !deprecated_args.empty?
+        puts "Warning: the follow args are deprecated by OpenAI and will be removed in the future: #{deprecated_args.keys.join(', ')}"
+        @deprecated_arg_warned = true
+      end
+    end
+
+    def warn_about_completions_endpoint
+      return if Instruct.suppress_warnings || @warned
+      puts "Warning: the completions endpoint is being shutdown by OpenAI in Jan 2025."
+      @warned = true
+    end
+  end
+end

data/lib/instruct/llms/openai/completion_response.rb

@@ -0,0 +1,20 @@
+class Instruct::OpenAI
+  # The completion API has been deprecated from OpenAI but some alternative service providers
+  # may still be using it. Leaving it in for now.
+  class CompletionResponse < Instruct::Gen::CompletionResponse
+
+    def call(chunk)
+      case Instruct::SymbolizeKeys.recursive(chunk)
+      in { choices: [ { text: new_content, finish_reason: } ] }
+        append_text_chunk(new_content)
+        done(finish_reason) unless finish_reason.nil?
+      in { error: { message: } }
+        raise RuntimeError, "OpenAI Client Error: #{message}"
+      else
+        raise RuntimeError, "Unexpected Chunk: #{chunk}"
+      end
+      chunk_processed
+    end
+
+  end
+end