Reference 2026-10-05 22:59 UTC to 2026-10-06 22:58 UTC

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```

867 

763```ruby868```ruby

764# Replace the illustrative IDs and URLs below with your own resource values.869# Replace the illustrative IDs and URLs below with your own resource values.

765require "openai"870require "openai"

760 return {"content": response.output_text}760 return {"content": response.output_text}

761```761```

762 762 

763```go

764func main() {

765 client := openai.NewClient()

766 server := &http.Server{

767 Addr: "127.0.0.1:8000",

768 Handler: newChatHandler(client),

769 ReadHeaderTimeout: 5 * time.Second,

770 }

771 log.Fatal(server.ListenAndServe())

772}

773 

774func newChatHandler(client openai.Client) http.Handler {

775 var mutex sync.Mutex

776 type sessionConversation struct {

777 ready chan struct{}

778 id string

779 err error

780 responseSlot chan struct{}

781 }

782 conversationsBySession := map[string]*sessionConversation{}

783 mux := http.NewServeMux()

784 mux.HandleFunc("POST /messages", func(w http.ResponseWriter, r *http.Request) {

785 var message struct {

786 Content string `json:"content"`

787 SessionID string `json:"session_id"`

788 }

789 if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&message); err != nil || strings.TrimSpace(message.Content) == "" || strings.TrimSpace(message.SessionID) == "" {

790 http.Error(w, "content and session_id must be non-empty strings", 400)

791 return

792 }

793 // A demo session map. Bind session IDs to authenticated users in your application.

794 mutex.Lock()

795 session, exists := conversationsBySession[message.SessionID]

796 if !exists {

797 session = &sessionConversation{ready: make(chan struct{}), responseSlot: make(chan struct{}, 1)}

798 conversationsBySession[message.SessionID] = session

799 }

800 mutex.Unlock()

801 if !exists {

802 go func() {

803 // Creation belongs to the shared session, not the first HTTP request.

804 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

805 defer cancel()

806 conversation, err := client.Conversations.New(ctx, conversations.ConversationNewParams{})

807 session.err = err

808 if err == nil {

809 session.id = conversation.ID

810 }

811 mutex.Lock()

812 if err != nil {

813 delete(conversationsBySession, message.SessionID)

814 }

815 close(session.ready)

816 mutex.Unlock()

817 }()

818 }

819 select {

820 case <-r.Context().Done():

821 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

822 return

823 case <-session.ready:

824 }

825 if session.err != nil {

826 http.Error(w, "Could not create conversation", http.StatusInternalServerError)

827 return

828 }

829 // Serialize responses within this conversation; waiting requests can cancel.

830 select {

831 case session.responseSlot <- struct{}{}:

832 defer func() { <-session.responseSlot }()

833 case <-r.Context().Done():

834 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

835 return

836 }

837 if r.Context().Err() != nil {

838 http.Error(w, "Request cancelled", http.StatusRequestTimeout)

839 return

840 }

841 // Replace this illustrative stored prompt ID with your prompt.

842 result, err := client.Responses.New(r.Context(), responses.ResponseNewParams{

843 Prompt: responses.ResponsePromptParam{

844 ID: "pmpt_123",

845 },

846 Input: responses.ResponseNewParamsInputUnion{

847 OfString: openai.String(message.Content),

848 },

849 Conversation: responses.ResponseNewParamsConversationUnion{

850 OfString: openai.String(session.id),

851 },

852 })

853 if err != nil || result.Status != responses.ResponseStatusCompleted {

854 http.Error(w, "Could not create response", 500)

855 return

856 }

857 w.Header().Set("Content-Type", "application/json")

858 if err := json.NewEncoder(w).Encode(map[string]string{

859 "content": result.OutputText(),

860 }); err != nil {

861 log.Print(err)

862 }

863 })

864 return mux

865}

866```