mirror of
https://github.com/we-promise/sure.git
synced 2026-09-05 14:51:15 +00:00
125666f59d
* Fix PDF vision path failing when poppler-utils is missing The Docker image omitted poppler-utils, so the OpenAI PDF vision path (which renders pages with pdftoppm before sending them upstream) always failed and the admin AI status page surfaced a generic "request failed" code rather than a useful reason. - install poppler-utils in the Docker base image (pdftoppm for the vision render path) - add an optional failure_code to Provider::Error, so probe errors can carry a machine-readable reason - in Provider::Openai::PdfProcessor#convert_pdf_to_images, check pdftoppm's return value and -- when the binary is genuinely missing, raise a Provider::Openai::Error with failure_code :render_missing_binary while preserving the existing [] fallback for other render failures - register the :render_missing_binary code in the admin locale so the AI status page shows a concrete, actionable message instead of "request failed" - AiHealth::Probe#failure_code now falls through to the default codes when an error's failure_code is nil, instead of returning nil - regression tests covering both the missing-binary and the present-but-fails cases Fixes the "PDF vision/native path" system check on instances where the image is built from the checked-in Dockerfile. * Fix missing-binary detection and preserve failure_code across the error boundary - convert_pdf_to_images: Kernel#system returns nil (not false) when the executable is absent; raise the coded error on rendered.nil? so a missing pdftoppm yields :render_missing_binary instead of a blank conversion. - Provider::Error#as_json + default_error_transformer: carry failure_code through serialization and error re-wrapping. - Drop the binary_missing? helper (nil result is the authoritative signal) and update regression tests to stub the real nil return value. - Add coverage for failure_code serialization/transformation. * Fix Provider::Error transformer syntax error and cover Faraday branch Addresses jjmata's blocking change-request: app/models/provider.rb:54 used a postfix `if` modifier inside a hash-argument/method-call argument list, which is not valid Ruby. `ruby -c` failed to parse the file, so the base class every provider inherits from could not autoload and the whole app (boot, requests, jobs, tests) was down. Rewrite default_error_transformer to build the optional failure_code keyword once (only when the error exposes a truthy code) and splat it, so both the Faraday::Error branch and the generic branch carry the code with no syntax error and no nil kwarg. Also add the two Faraday-branch regression tests that were missing (failure_code preservation + response-body-to-details extraction), guarding this exact class of broken-argument bug with real assertions. Verification: ruby -c passes on provider.rb, pdf_processor.rb, probe.rb, and both test files; plus a behavioral harness against the real provider.rb source covering the coded/plain/nil-code, Faraday-coded, Faraday-no-code, nil-response, and generic-error paths (19/19 pass). Ref: we-promise/sure#3275 * Document the methods added or changed by this PR * Add poppler-utils to devcontainer image --------- Co-authored-by: hermes-on-behalf-of-jon <hermes@nousresearch.com> Co-authored-by: jaysbeekay <jaysbeekay@users.noreply.github.com> Co-authored-by: sure-admin <sure-admin@splashblot.com>
77 lines
2.2 KiB
Ruby
77 lines
2.2 KiB
Ruby
class Provider
|
|
Response = Data.define(:success?, :data, :error)
|
|
|
|
class Error < StandardError
|
|
attr_reader :details, :failure_code
|
|
|
|
# Builds a provider error. `details` holds opaque response metadata
|
|
# (e.g. the upstream body); `failure_code` is an optional symbol the
|
|
# admin AI status page and health probe key on so they can show a
|
|
# specific, actionable reason instead of a generic message.
|
|
def initialize(message, details: nil, failure_code: nil)
|
|
super(message)
|
|
@details = details
|
|
@failure_code = failure_code
|
|
end
|
|
|
|
# Serialized form for API consumers. Includes `failure_code` so
|
|
# downstream UI can branch on the reason rather than the message text.
|
|
def as_json
|
|
{
|
|
message: message,
|
|
details: details,
|
|
failure_code: failure_code
|
|
}
|
|
end
|
|
end
|
|
|
|
private
|
|
PaginatedData = Data.define(:paginated, :first_page, :total_pages)
|
|
UsageData = Data.define(:used, :limit, :utilization, :plan)
|
|
|
|
def with_provider_response(error_transformer: nil, &block)
|
|
data = yield
|
|
|
|
Response.new(
|
|
success?: true,
|
|
data: data,
|
|
error: nil,
|
|
)
|
|
rescue => error
|
|
transformed_error = if error_transformer
|
|
error_transformer.call(error)
|
|
else
|
|
default_error_transformer(error)
|
|
end
|
|
|
|
Response.new(
|
|
success?: false,
|
|
data: nil,
|
|
error: transformed_error
|
|
)
|
|
end
|
|
|
|
# Fallback transformation applied by `with_provider_response` when no
|
|
# `error_transformer:` is given. Re-wraps an arbitrary rescue into a
|
|
# `self.class::Error`, carrying over the error's `failure_code` (when
|
|
# present and truthy) and, for Faraday errors, the response body as
|
|
# `details`. Subclasses may override this to customise.
|
|
def default_error_transformer(error)
|
|
kwargs = if error.respond_to?(:failure_code) && error.failure_code
|
|
{ failure_code: error.failure_code }
|
|
else
|
|
{}
|
|
end
|
|
|
|
if error.is_a?(Faraday::Error)
|
|
self.class::Error.new(
|
|
error.message,
|
|
details: error.response&.dig(:body),
|
|
**kwargs
|
|
)
|
|
else
|
|
self.class::Error.new(error.message, **kwargs)
|
|
end
|
|
end
|
|
end
|