openairesponses

type Codec ¶

type Codec struct{}

Codec is the OpenAI Responses API wire dialect expressed as a codec.Codec (and, via DecodeStream in stream.go, a codec.StreamingCodec) AND, unlike codec/openaiapi today, a full codec.ServerCodec: this package is built from scratch with both directions, since unlike Anthropic there is no prior client-only package to extend. It is stateless (an empty struct with value-receiver methods), so one value is safely shared across goroutines. The methods delegate to package-level free functions so the method surface and the free surface cannot diverge.

func (Codec) DecodeEvent(event []byte) ([]content.Chunk, error)

func (Codec) DecodeRequest(req *http.Request) (codec.DecodedRequest, error)

func (Codec) DecodeResponse(body []byte) (*inference.Response, error)

func (Codec) DecodeStream(resp *http.Response) (*stream.StreamReader[content.Chunk], error)

func (Codec) EncodeRequest(req inference.Request, mode codec.RequestMode) (codec.EncodedRequest, error)

func (Codec) MatchRequest(req *http.Request) bool

func (Codec) OpenStream(w http.ResponseWriter) (codec.StreamEncoder, error)

func (Codec) WriteError(w http.ResponseWriter, err error)

func (Codec) WriteResponse(w http.ResponseWriter, resp *inference.Response) error

type DuplicateKeyError ¶

type DuplicateKeyError struct {
	Key string
}

DuplicateKeyError reports a request body with a duplicate JSON object member name. encoding/json silently takes the last occurrence; this codec rejects the request instead so a client cannot smuggle a semantically different value past a naive review of the first occurrence.

func (e *DuplicateKeyError) Error() string

type SamplingRangeError ¶

type SamplingRangeError struct {
	Field string
	Value float64
	Min   float64
	Max   float64
}

SamplingRangeError is returned by the encoder when a sampling knob falls outside the interval CreateResponse declares for it — temperature [0, 2], top_p [0, 1], reached through CreateModelResponseProperties -> ModelResponseProperties, the same schema Chat Completions inherits.

Min and Max are carried on the error rather than baked into the message because the two fields have DIFFERENT bounds here, and because the bound that matters is the destination's: Anthropic and Bedrock cap temperature at 1 and OpenAI at 2, so a session moved between providers carries a value that was legal at its source into a request where it is not. The shared model.Sampling vocabulary is wide enough to hold every dialect's range, so the narrowing has to happen in the codec that owns the destination contract. This mirrors the sibling openaiapi error of the same name.

func (e *SamplingRangeError) Error() string

type ServerDecodeError ¶

type ServerDecodeError struct {
	Reason string
	Detail string
}

ServerDecodeError reports a native Responses request body this codec cannot decode into the provider-neutral vocabulary: malformed shape, a missing required field, or a recognized-but-unsupported feature. Reason is a short machine-checkable diagnostic code; Detail elaborates for logs/messages.

func (e *ServerDecodeError) Error() string

type StreamAPIError ¶

type StreamAPIError struct {
	Code    string
	Message string
}

StreamAPIError reports a native `response.failed` event received after a streaming request crossed the successful HTTP-status boundary. It retains only the provider's structured error code and message, never the raw response frame.

func (e *StreamAPIError) Error() string

type StreamDecodeError ¶

type StreamDecodeError struct {
	Reason string
	Err    error
}

StreamDecodeError reports a Responses stream that is framed and parseable but structurally wrong — currently only a body that reaches EOF without one of the union's terminal response events (response.completed or response.incomplete; response.failed and the top-level error event abort with a *StreamAPIError instead), which means the answer was truncated in flight. It never includes the raw provider payload in its diagnostic. Named and shaped after the equivalent type in codec/bedrockconverse and codec/geminiapi. It lives here rather than in errors.go because the gate it serves is the only thing that raises it.

func (e *StreamDecodeError) Error() string

func (e *StreamDecodeError) Unwrap() error

type StreamEventDecodeError ¶

type StreamEventDecodeError struct{ Err error }

StreamEventDecodeError reports malformed JSON inside an otherwise successfully framed Responses stream. Unknown well-formed events remain forward-compatible skips.

func (e *StreamEventDecodeError) Error() string

func (e *StreamEventDecodeError) Unwrap() error

type StreamTerminatedError ¶

type StreamTerminatedError struct{}

StreamTerminatedError is returned by StreamEncoder.WriteChunk, Finish, or Fail once the stream has already been terminated by a prior Finish or Fail call, per the single-termination-ownership rule in codec.StreamEncoder.

func (e *StreamTerminatedError) Error() string

type UnsupportedBlockError ¶

type UnsupportedBlockError struct {
	Block  string
	Reason string
}

UnsupportedBlockError is returned by an encoder when a content block cannot be placed on the wire: a concrete type this dialect does not model in that position (audio anywhere, any non-text block in a text-only tool result), or a block whose value the position's schema cannot carry (a document with no name to attach its inline data to). Block holds the Go type name for diagnosis; Reason, when set, names the specific limitation — mirroring the sibling bedrockconverse and openaiapi codecs' errors of the same name.

func (e *UnsupportedBlockError) Error() string

type UnsupportedChunkError ¶

type UnsupportedChunkError struct {
	Chunk string
}

UnsupportedChunkError is returned when a content.Chunk has a concrete type this dialect's stream encoder does not model. content.Chunk is a sealed interface, so this only guards against future variants added to the vocabulary.

func (e *UnsupportedChunkError) Error() string

type UnsupportedConversationError ¶

type UnsupportedConversationError struct {
	Conversation string
}

UnsupportedConversationError is returned by the encoder when a conversation turn has a concrete type outside the closed content.Conversation union the dialect maps (user / assistant / tool-result / system). Conversation holds the Go type name for diagnosis.

func (e *UnsupportedConversationError) Error() string