diff --git a/src/llm/src/bedrock/client.lua b/src/llm/src/bedrock/client.lua index e50357f..dbf484d 100644 --- a/src/llm/src/bedrock/client.lua +++ b/src/llm/src/bedrock/client.lua @@ -8,6 +8,8 @@ local thinking = require("thinking") local sigv4 = require("sigv4") local credentials = require("bedrock_credentials") +local stream_redactors = setmetatable({}, { __mode = "k" }) + local bedrock_client = {} bedrock_client._http_client = http_client @@ -108,7 +110,7 @@ local function parse_error_response(http_response: transport.HttpResponse): tran end -- Make a signed POST request to a bedrock-runtime path -local function signed_request(path, payload, options) +local function signed_request(path, payload, options): (any, transport.RequestError?) options = options or {} local config = resolve_config() local timeout, timeout_err = transport.resolve_timeout(options.timeout, "options.timeout", config.timeout, config.timeout_error) @@ -181,25 +183,29 @@ local function signed_request(path, payload, options) local retry = transport.request_retry(options.retry, config.retry) local response, request_error = transport.send(send_once, parse_error_response, retry, config.deadline_at) if not response then - return nil, request_error + return nil, transport.redact_error(request_error, transport.request_secrets(signed_headers, config.headers)) end if options.stream and response.stream then - return { + local stream_response = { stream = response.stream, status_code = response.status_code, headers = response.headers, metadata = extract_response_metadata(response) } + stream_redactors[stream_response] = function(value) + return transport.redact_error(value, transport.request_secrets(signed_headers, config.headers)) + end + return stream_response end local parsed, parse_err = json.decode(tostring(response.body)) if parse_err then - return nil, { + return nil, transport.redact_error({ status_code = response.status_code, message = "Failed to parse Bedrock response: " .. parse_err, metadata = extract_response_metadata(response) - } + }, transport.request_secrets(signed_headers, config.headers)) end parsed.metadata = extract_response_metadata(response) @@ -405,6 +411,7 @@ end -- Process ConverseStream eventstream, dispatching to callbacks as each event arrives function bedrock_client.process_converse_stream(stream_response, callbacks) + local redact_error = stream_redactors[stream_response] if not stream_response or not stream_response.stream then return nil, "Invalid stream response" end @@ -431,6 +438,7 @@ function bedrock_client.process_converse_stream(stream_response, callbacks) -- Converse stream events use top-level keys instead of a "type" field if event._exception then local exc = event._exception + if redact_error then exc = redact_error(exc) end error_reported = true on_error({ message = exc.message, type = exc.type }) return tostring(exc.message) @@ -534,6 +542,7 @@ function bedrock_client.process_converse_stream(stream_response, callbacks) local stream_err = read_eventstream(stream_response.stream, handle_event) if stream_err then + if redact_error then stream_err = redact_error(stream_err) end if not error_reported then on_error({ message = stream_err }) end diff --git a/src/llm/src/claude/client.lua b/src/llm/src/claude/client.lua index 2524516..acd6c47 100644 --- a/src/llm/src/claude/client.lua +++ b/src/llm/src/claude/client.lua @@ -5,6 +5,8 @@ local ctx = require("ctx") local transport = require("transport") local thinking = require("thinking") +local stream_redactors = setmetatable({}, { __mode = "k" }) + type ClaudeConfig = { api_key: string?, base_url: string, @@ -157,7 +159,6 @@ local function prepare_headers(api_key, api_version, beta_features, method, addi return headers end - function claude_client.request(endpoint_path, payload, options): (any, transport.RequestError?) options = options or {} local method = options.method or "POST" @@ -207,25 +208,29 @@ function claude_client.request(endpoint_path, payload, options): (any, transport local retry = transport.request_retry(options.retry, config.retry) local response, request_error = transport.send(send_once, parse_error_response, retry, config.deadline_at) if not response then - return nil, request_error + return nil, transport.redact_error(request_error, transport.request_secrets(headers, config.headers)) end if options.stream and response.stream then - return { + local stream_response = { stream = response.stream, status_code = response.status_code, headers = response.headers, metadata = extract_response_metadata(response) } + stream_redactors[stream_response] = function(value) + return transport.redact_error(value, transport.request_secrets(headers, config.headers)) + end + return stream_response end local parsed, parse_err = json.decode(response.body or "") if parse_err then - return nil, { + return nil, transport.redact_error({ status_code = response.status_code, message = "Failed to parse Claude response: " .. parse_err, metadata = extract_response_metadata(response) - } + }, transport.request_secrets(headers, config.headers)) end parsed.metadata = extract_response_metadata(response) @@ -253,6 +258,7 @@ local function stream_result(full_content, tool_calls, thinking_blocks, layout, end function claude_client.process_stream(stream_response, callbacks) + local redact_error = stream_redactors[stream_response] if not stream_response or not stream_response.stream then return nil, "Invalid stream response" end @@ -278,6 +284,7 @@ function claude_client.process_stream(stream_response, callbacks) local chunk, err = stream_response.stream:read() if err then + if redact_error then err = redact_error(err) end on_error({ message = err }) return nil, err end @@ -419,6 +426,7 @@ function claude_client.process_stream(stream_response, callbacks) return full_content, nil, result elseif event_type == "error" then if data and data.error then + if redact_error then data.error = redact_error(data.error) end on_error(data.error) return nil, data.error.message end diff --git a/src/llm/src/google/client.lua b/src/llm/src/google/client.lua index b9d4702..9a89b74 100644 --- a/src/llm/src/google/client.lua +++ b/src/llm/src/google/client.lua @@ -4,6 +4,18 @@ local output = require("output") local transport = require("transport") local mapper = require("google_mapper") +local stream_redactors = setmetatable({}, { __mode = "k" }) + +local function redact_request_error(value, http_options, method) + local configured_headers = {} + for name in pairs(http_options.headers) do + if name ~= "Accept" and (name ~= "Content-Type" or method == "GET") then + configured_headers[name] = true + end + end + return transport.redact_error(value, transport.request_secrets(http_options.headers, configured_headers)) +end + type StreamInput = { stream: any, metadata: table?, @@ -71,6 +83,7 @@ local function parse_error_response(http_response: transport.HttpResponse): tran end function client.process_stream(stream_response: StreamInput, callbacks: StreamCallbacks?): (string?, string?, StreamResult?) + local redact_error = stream_redactors[stream_response] if not stream_response or not stream_response.stream then return nil, "Invalid stream response" end @@ -101,7 +114,8 @@ function client.process_stream(stream_response: StreamInput, callbacks: StreamCa if data_line == "[DONE]" then done = true; return nil end local parsed, parse_err = json.decode(data_line) if parse_err or type(parsed) ~= "table" then - return "Invalid Google stream event: " .. tostring(parse_err or "expected object") + local message = "Invalid Google stream event: " .. tostring(parse_err or "expected object") + return redact_error and redact_error(message) or message end if parsed.error then @@ -110,6 +124,7 @@ function client.process_stream(stream_response: StreamInput, callbacks: StreamCa code = parsed.error.code, status = parsed.error.status } + if redact_error then stream_error_info = redact_error(stream_error_info) end return tostring(stream_error_info.message) end @@ -158,7 +173,10 @@ function client.process_stream(stream_response: StreamInput, callbacks: StreamCa while not done do local chunk, err = stream_response.stream:read() - if err then on_error({ message = err }); return nil, err end + if err then + if redact_error then err = redact_error(err) end + on_error({ message = err }); return nil, err + end if not chunk then -- Some gateways omit the final blank line. Do not discard a final event, -- but reject a torn/malformed JSON payload rather than silently losing it. @@ -201,7 +219,7 @@ end --- Process a streaming response and send chunks via output.streamer. --- Returns an aggregated Google-like response compatible with map_success_response(). -local function handle_stream_response(response, http_options) +local function handle_stream_response(response, http_options, method) local reply_to = http_options.stream_reply_to :: string? local topic = http_options.stream_topic :: string? local streamer = output.streamer(reply_to, topic, http_options.stream_buffer_size or 10) @@ -252,10 +270,11 @@ local function handle_stream_response(response, http_options) end, } - local _, stream_err = client.process_stream( - { stream = response.stream, metadata = {} }, - callbacks :: StreamCallbacks - ) + local stream_response = { stream = response.stream, metadata = {} } + stream_redactors[stream_response] = function(value) + return redact_request_error(value, http_options, method) + end + local _, stream_err = client.process_stream(stream_response, callbacks :: StreamCallbacks) if stream_err then return nil, { @@ -314,12 +333,12 @@ function client.request(method, url, http_options, retry: transport.Retry?, dead local failure: any = request_error failure.stream_started = false end - return nil, request_error + return nil, redact_request_error(request_error, http_options, method) end -- Streaming: process stream, send chunks via streamer, return aggregated response if http_options.stream and response.stream then - return handle_stream_response(response, http_options) + return handle_stream_response(response, http_options, method) end local parsed, parse_err = json.decode(response.body or "") @@ -329,7 +348,7 @@ function client.request(method, url, http_options, retry: transport.Retry?, dead message = "Failed to parse Google response: " .. parse_err, metadata = {} } - return nil, parse_error + return nil, redact_request_error(parse_error, http_options, method) end parsed.metadata = extract_response_metadata(parsed) diff --git a/src/llm/src/openai/client.lua b/src/llm/src/openai/client.lua index f092924..e878c5b 100644 --- a/src/llm/src/openai/client.lua +++ b/src/llm/src/openai/client.lua @@ -5,6 +5,8 @@ local env = require("env") local ctx = require("ctx") local transport = require("transport") +local stream_redactors = setmetatable({}, { __mode = "k" }) + type OpenAIConfig = { api_key: string?, base_url: string, @@ -172,33 +174,37 @@ function openai_client.request(endpoint_path, payload, options) local retry = transport.request_retry(options.retry, config.retry) local response, request_error = transport.send(send_once, parse_error_response, retry, config.deadline_at) if not response then - return nil, request_error + return nil, transport.redact_error(request_error, transport.request_secrets(headers, config.headers)) end if options.stream and response.stream then - return { + local stream_response = { stream = response.stream, status_code = response.status_code, headers = response.headers, metadata = extract_response_metadata(response) } + stream_redactors[stream_response] = function(value) + return transport.redact_error(value, transport.request_secrets(headers, config.headers)) + end + return stream_response end local parsed, parse_err = json.decode(response.body or "") if parse_err then - return nil, { + return nil, transport.redact_error({ status_code = response.status_code, message = "Failed to parse OpenAI response: " .. parse_err, metadata = extract_response_metadata(response) - } + }, transport.request_secrets(headers, config.headers)) end if type(parsed) ~= "table" then - return nil, { + return nil, transport.redact_error({ status_code = response.status_code, message = "Invalid OpenAI response: expected a JSON object", metadata = extract_response_metadata(response) - } + }, transport.request_secrets(headers, config.headers)) end parsed.metadata = extract_response_metadata(response) @@ -210,6 +216,7 @@ end -- names the event (e.g. response.output_text.delta). Multiple events are -- separated by a blank line (\n\n). function openai_client.process_stream(stream_response, callbacks): (string?, any, any) + local redact_error = stream_redactors[stream_response] if not stream_response or not stream_response.stream then return nil, "Invalid stream response" end @@ -314,6 +321,7 @@ function openai_client.process_stream(stream_response, callbacks): (string?, any local chunk, err = stream_response.stream:read() if err then + if redact_error then err = redact_error(err) end on_error(err) return nil, err end @@ -465,6 +473,7 @@ function openai_client.process_stream(stream_response, callbacks): (string?, any type = err_payload and err_payload.type, param = err_payload and err_payload.param } + if redact_error then error_info = redact_error(error_info) end on_error(error_info) close_stream() return nil, error_info.message, { error = error_info } diff --git a/src/llm/src/openai_compat/client.lua b/src/llm/src/openai_compat/client.lua index 1e0f9e7..5d7bb17 100644 --- a/src/llm/src/openai_compat/client.lua +++ b/src/llm/src/openai_compat/client.lua @@ -4,6 +4,8 @@ local env = require("env") local ctx = require("ctx") local transport = require("transport") +local stream_redactors = setmetatable({}, { __mode = "k" }) + type OpenAIConfig = { api_key: string?, base_url: string, @@ -211,17 +213,21 @@ function openai_client.request(endpoint_path, payload, options) local retry = transport.request_retry(options.retry, config.retry) local response, request_error = transport.send(send_once, parse_error_response, retry, config.deadline_at) if not response then - return nil, request_error + return nil, transport.redact_error(request_error, transport.request_secrets(headers, config.headers)) end -- Handle streaming response if options.stream and response.stream then - return { + local stream_response = { stream = response.stream, status_code = response.status_code, headers = response.headers, metadata = extract_response_metadata(response) } + stream_redactors[stream_response] = function(value) + return transport.redact_error(value, transport.request_secrets(headers, config.headers)) + end + return stream_response end -- Parse non-streaming response @@ -232,7 +238,7 @@ function openai_client.request(endpoint_path, payload, options) message = "Failed to parse OpenAI response: " .. parse_err, metadata = extract_response_metadata(response) } - return nil, parse_error + return nil, transport.redact_error(parse_error, transport.request_secrets(headers, config.headers)) end -- Add metadata to the response @@ -243,6 +249,7 @@ end -- Process streaming response function openai_client.process_stream(stream_response, callbacks) + local redact_error = stream_redactors[stream_response] if not stream_response or not stream_response.stream then return nil, "Invalid stream response" end @@ -273,6 +280,7 @@ function openai_client.process_stream(stream_response, callbacks) local chunk, err = stream_response.stream:read() if err then + if redact_error then err = redact_error(err) end on_error(err) return nil, err end @@ -319,6 +327,7 @@ function openai_client.process_stream(stream_response, callbacks) type = parsed_error.error.type, param = parsed_error.error.param } + if redact_error then error_info = redact_error(error_info) end on_error(error_info) return nil, error_info.message, { error = error_info } end @@ -365,6 +374,7 @@ function openai_client.process_stream(stream_response, callbacks) local parsed, parse_err = json.decode(tostring(data_line)) if parse_err or type(parsed) ~= "table" then local message = "Invalid OpenAI stream event: " .. tostring(parse_err or "expected a JSON object") + if redact_error then message = redact_error(message) end on_error({ message = message, status_code = 500 }) return nil, message end diff --git a/src/llm/src/typesafe/client.lua b/src/llm/src/typesafe/client.lua index f057a05..3a44664 100644 --- a/src/llm/src/typesafe/client.lua +++ b/src/llm/src/typesafe/client.lua @@ -199,16 +199,16 @@ function typesafe_client.request(endpoint_path, payload, options) local retry = transport.request_retry(options.retry, config.retry) local response, request_error = transport.send(send_once, parse_error_response, retry, config.deadline_at) if not response then - return nil, request_error + return nil, transport.redact_error(request_error, transport.request_secrets(headers, config.headers)) end local parsed, parse_err = json.decode(response.body or "") if parse_err or type(parsed) ~= "table" then - return nil, { + return nil, transport.redact_error({ status_code = response.status_code, message = "Failed to parse TypeSafe response: " .. tostring(parse_err or "expected a JSON object"), metadata = extract_response_metadata(response) - } + }, transport.request_secrets(headers, config.headers)) end parsed.metadata = extract_response_metadata(response) diff --git a/src/llm/src/util/_index.yaml b/src/llm/src/util/_index.yaml index 29ec6bf..39f8f2c 100644 --- a/src/llm/src/util/_index.yaml +++ b/src/llm/src/util/_index.yaml @@ -34,6 +34,7 @@ entries: source: file://transport.lua modules: - time + - json - name: route kind: library.lua diff --git a/src/llm/src/util/transport.lua b/src/llm/src/util/transport.lua index 8b508e9..4331adf 100644 --- a/src/llm/src/util/transport.lua +++ b/src/llm/src/util/transport.lua @@ -1,4 +1,5 @@ local time = require("time") +local json = require("json") type Retry = { attempts: number, @@ -45,6 +46,103 @@ local transport = {} transport._time = time +-- Snapshot only values sent on this request; configured headers may carry +-- credentials under arbitrary names. Generated protocol headers are not secrets. +function transport.request_secrets(headers: {[string]: string}, configured_headers: {[string]: any}?): {string} + local secrets: {string} = {} + local seen: {[string]: boolean} = {} + local configured: {[string]: boolean} = {} + for name in pairs(configured_headers or {}) do configured[tostring(name):lower()] = true end + local function add(value: string?) + if value and value ~= "" and not seen[value] then + seen[value] = true + secrets[#secrets + 1] = value + end + end + for name, value in pairs(headers) do + local lower = name:lower() + if configured[lower] or lower == "authorization" or lower == "x-api-key" + or lower == "x-goog-api-key" or lower == "x-amz-security-token" then + add(value) + add(value:match("^[Bb][Ee][Aa][Rr][Ee][Rr]%s+(.+)$")) + if lower == "authorization" then + add(value:match("Credential=([^/ ,]+)")) + add(value:match("Signature=([^ ,]+)")) + end + end + end + return secrets +end + +-- Replace credential substrings and their serialized forms, including table keys +-- and nested diagnostics, without interpreting patterns in secrets. +function transport.redact_error(value: any, secrets: {string}?): any + if not secrets or #secrets == 0 then return value end + local variants: {string} = {} + local seen: {[string]: boolean} = {} + local function add(value: string) + if not seen[value] then + seen[value] = true + variants[#variants + 1] = value + end + end + for _, secret in ipairs(secrets) do + if secret ~= "" then + add(secret) + add(json.encode(secret):sub(2, -2)) + local encoded = secret:gsub("([^%w%-._~])", function(char: string): string + return string.format("%%%02X", string.byte(char)) + end) + add(encoded) + add(encoded:gsub("%%(%x%x)", string.lower)) + local form = encoded:gsub("%%20", "+") + add(form) + add(form:gsub("%%(%x%x)", string.lower)) + end + end + table.sort(variants, function(a: string, b: string): boolean + if #a == #b then return a < b end + return #a > #b + end) + local function redact_string(message: string): string + local parts: {string} = {} + local position = 1 + while position <= #message do + local first: integer? = nil + local last: integer = 0 + for _, secret in ipairs(variants) do + local start_at, end_at = message:find(secret, position, true) + if start_at and end_at and (not first or start_at < first) then + first, last = start_at, end_at + end + end + if not first then + parts[#parts + 1] = message:sub(position) + break + end + parts[#parts + 1] = message:sub(position, first - 1) + parts[#parts + 1] = "[REDACTED]" + position = last + 1 + end + return table.concat(parts) + end + local copies: {[any]: any} = {} + local function redact(item: any): any + if type(item) == "string" then return redact_string(item) end + if type(item) == "userdata" then + return errors.new({ message = redact_string(item:message()), kind = item:kind(), + retryable = item:retryable(), details = redact(item:details()) }) + end + if type(item) ~= "table" then return item end + if copies[item] then return copies[item] end + local result = {} + copies[item] = result + for key, nested in pairs(item) do result[redact(key)] = redact(nested) end + return result + end + return redact(value) +end + function transport.now_ms(): number return math.floor(transport._time.now():unix_nano() / 1000000) end diff --git a/src/llm/test/_index.yaml b/src/llm/test/_index.yaml index 7ce706c..1ac3f1d 100644 --- a/src/llm/test/_index.yaml +++ b/src/llm/test/_index.yaml @@ -2,6 +2,29 @@ version: "1.0" namespace: app entries: + - name: provider_error_redaction_test + kind: function.lua + meta: {type: test, group: LLM / Drivers} + source: file://provider_error_redaction_test.lua + method: run + modules: [json, process] + imports: + test: wippy.test:test + output: wippy.llm:output + transport: wippy.llm.util:transport + openai_client: wippy.llm.openai:client + openai_mapper: wippy.llm.openai:mapper + openai_compat_client: wippy.llm.openai_compat:client + openai_compat_mapper: wippy.llm.openai_compat:mapper + claude_client: wippy.llm.claude:client + claude_mapper: wippy.llm.claude:mapper + typesafe_client: wippy.llm.typesafe:client + typesafe_mapper: wippy.llm.typesafe:mapper + bedrock_client: wippy.llm.bedrock:client + bedrock_mapper: wippy.llm.bedrock:mapper + google_client: wippy.llm.google:client + google_mapper: wippy.llm.google:mapper + - name: dep.wippy.test kind: ns.dependency meta: diff --git a/src/llm/test/provider_error_redaction_test.lua b/src/llm/test/provider_error_redaction_test.lua new file mode 100644 index 0000000..2cc553a --- /dev/null +++ b/src/llm/test/provider_error_redaction_test.lua @@ -0,0 +1,277 @@ +local test = require("test") +local json = require("json") +local output = require("output") +local transport = require("transport") + +local providers = { + { name = "openai", client = require("openai_client"), mapper = require("openai_mapper") }, + { name = "openai_compat", client = require("openai_compat_client"), mapper = require("openai_compat_mapper") }, + { name = "claude", client = require("claude_client"), mapper = require("claude_mapper") }, + { name = "typesafe", client = require("typesafe_client"), mapper = require("typesafe_mapper") }, + { name = "bedrock", client = require("bedrock_client"), mapper = require("bedrock_mapper") }, + { name = "google", client = require("google_client"), mapper = require("google_mapper") }, +} + +local key = 'echo-timeout-key."\\ /+fixture' +local header_secret = "echo-header-%value" +local bearer = "echo-bearer-fixture" +local encoded_key = json.encode(key):sub(2, -2) +local url_key = key:gsub("([^%w%-._~])", function(char) return string.format("%%%02X", string.byte(char)) end) +local diagnostic = "Denied " .. key .. " / " .. header_secret .. " / Bearer " .. bearer +local sanitized = "Denied [REDACTED] / [REDACTED] / [REDACTED]" + +local function assert_clean(value) + if type(value) == "userdata" then + assert_clean(value:message()) + assert_clean(value:details() or {}) + return + end + if type(value) == "table" then + for name, nested in pairs(value) do + assert_clean(name) + assert_clean(nested) + end + return + end + if type(value) ~= "string" then return end + for _, secret in ipairs({ key, encoded_key, url_key, url_key:lower(), header_secret, bearer }) do + test.is_nil(value:find(secret, 1, true), "credential remains in diagnostic") + end +end + +local function upstream_error() + return { + message = diagnostic, + type = "authentication_error", + code = "invalid_api_key", + param = { nested = { message = diagnostic, [key] = header_secret }, retained = 7, encoded = encoded_key .. " / " .. url_key }, + metadata = { raw = json.encode({ message = diagnostic }), provider_name = header_secret }, + } +end + +local function stream_once(data, read_error) + local consumed = false + return { read = function() + if consumed then return nil end + consumed = true + return data, read_error + end } +end + +local function bedrock_frame(body) + local function header(name, value) + return string.char(#name) .. name .. string.char(7) .. string.pack(">I2", #value) .. value + end + local headers = header(":message-type", "exception") .. header(":exception-type", "validationException") + local payload = json.encode(body) + return string.pack(">I4I4I4", 16 + #headers + #payload, #headers, 0) + .. headers .. payload .. string.pack(">I4", 0) +end + +return test.run_cases(function() + for _, provider in ipairs(providers) do + describe(provider.name .. " credential error redaction", function() + local client: any = provider.client + local saved = {} + local context + local collect_secrets + local secret_collections + before_each(function() + secret_collections = 0 + collect_secrets = transport.request_secrets + transport.request_secrets = function(...) + secret_collections = secret_collections + 1 + return collect_secrets(...) + end + for _, name in ipairs({ "_ctx", "_env", "_http_client", "_credentials", "_sigv4" }) do + saved[name] = client[name] + end + context = { api_key = key, headers = { + Authorization = "Bearer " .. key, ["X-Custom-Secret"] = header_secret, + ["X-Other-Secret"] = "Bearer " .. bearer, + } } + client._ctx = { all = function() return context end } + client._env = { get = function() return nil end } + if provider.name == "bedrock" then + client._credentials = { resolve = function() + return { access_key = key, secret_key = "unused-signing-key", session_token = bearer } + end } + client._sigv4 = { sign_request = function(request) + request.headers.Authorization = "Bearer " .. bearer + request.headers["x-amz-security-token"] = key + return request.headers + end } + end + end) + after_each(function() + transport.request_secrets = collect_secrets + for _, name in ipairs({ "_ctx", "_env", "_http_client", "_credentials", "_sigv4" }) do + client[name] = saved[name] + end + end) + + local function request(streaming: boolean): (any, any) + if provider.name == "google" then + return client.request("POST", "https://api.example.test/generate", { + headers = { ["x-goog-api-key"] = key, Authorization = "Bearer " .. bearer, + ["X-Custom-Secret"] = header_secret }, + stream = streaming, stream_reply_to = "fixture-pid", stream_topic = "fixture-errors", + }) + elseif provider.name == "bedrock" then + if streaming then + local converse_stream = client.converse_stream + assert(converse_stream) + return converse_stream("model", {}) + end + local converse = client.converse + assert(converse) + return converse("model", {}) + end + return client.request("/generate", {}, { stream = streaming }) + end + + local function build_error(err) + return output.errors.generate():classifier(provider.mapper.classify_error):from(err):build() + end + + it("redacts HTTP messages and nested details before logging or returning", function() + client._http_client = { post = function() + return { status_code = 401, body = json.encode({ error = upstream_error(), + detail = upstream_error(), message = diagnostic }), + headers = { ["X-Request-Id"] = header_secret, ["request-id"] = header_secret, + ["x-amzn-requestid"] = header_secret, ["x-typesafe-request-id"] = header_secret } } + end } + for _, streaming in ipairs({ false, true }) do + local response, err = request(streaming) + test.is_nil(response) + test.eq(err.status_code, 401) + test.eq(err.message, sanitized) + assert_clean(err) + test.ok(secret_collections > 0) + local built = build_error(err) + assert_clean(built:message()) + assert_clean(built:details()) + test.eq(built:kind(), errors.PERMISSION_DENIED) + test.is_false(built:retryable()) + end + end) + + it("preserves successful provider content", function() + client._http_client = { post = function() + return { status_code = 200, headers = {}, body = json.encode({ message = diagnostic }) } + end } + local response, err = request(false) + test.is_nil(err) + test.eq(response.message, diagnostic) + test.eq(secret_collections, 0) + end) + + if provider.name ~= "typesafe" then + it("keeps successful streams free of secret collection and public credential state", function() + mock("process.send", function() return true end) + client._http_client = { post = function() + return { status_code = 200, headers = {}, stream = stream_once(nil) } + end } + local response, err = request(true) + test.is_nil(err) + test.eq(secret_collections, 0) + if provider.name ~= "google" then + for name in pairs(response) do + test.ok(name == "stream" or name == "status_code" or name == "headers" or name == "metadata") + end + local process_stream = provider.name == "bedrock" and client.process_converse_stream or client.process_stream + assert(process_stream) + process_stream(response, {}) + test.eq(secret_collections, 0) + end + end) + end + + it("redacts connection errors without changing their shape", function() + client._http_client = { post = function() return nil, diagnostic end } + local response, err = request(false) + test.is_nil(response) + test.eq(err.status_code, 0) + test.eq(err.message, "Connection failed: " .. sanitized) + assert_clean(err) + assert_clean(build_error(err):message()) + end) + + if provider.name ~= "typesafe" then + for _, mode in ipairs({ "event", "string", "native" }) do + local read_failure = mode ~= "event" + it("redacts " .. mode .. " stream failures before callbacks and chunks", function() + local read_error = mode == "native" and errors.new({ message = diagnostic, + kind = errors.UNAVAILABLE, retryable = true, details = { nested = { message = diagnostic } } }) or diagnostic + local chunks = {} + mock("process.send", function(_, _, chunk) + chunks[#chunks + 1] = chunk + return true + end) + local data + if provider.name == "bedrock" then data = bedrock_frame(upstream_error()) + elseif provider.name == "claude" then + data = "event: error\ndata: " .. json.encode({ type = "error", error = upstream_error() }) .. "\n\n" + else + data = "data: " .. json.encode({ type = "error", error = upstream_error() }) .. "\n\n" + end + client._http_client = { post = function() + local stream = stream_once(read_failure and nil or data, read_failure and read_error or nil) + if provider.name == "google" then + local reads = 0 + stream = { read = function() + reads = reads + 1 + if reads == 1 then + return 'data: {"candidates":[{"content":{"parts":[{"text":"prefix content"}]}}]}\n\n' + elseif reads == 2 then + return read_failure and nil or data, read_failure and read_error or nil + end + return nil + end } + end + return { status_code = 200, headers = {}, stream = stream } + end } + local response, err = request(true) + if provider.name ~= "google" then + test.is_nil(err) + test.is_nil(response._request_secrets) + test.eq(secret_collections, 0) + -- Stream diagnostics belong to the dispatched request even if configuration changes. + context = { api_key = "next-request-key", headers = {} } + local streamer = output.streamer("fixture-pid", "fixture-errors") + assert(streamer) + local callbacks = { on_error = function(info) + assert_clean(info) + local normalized = info + if type(info) == "userdata" then normalized = { message = info:message() } + elseif type(info) == "string" then normalized = { message = info } + elseif type(info.message) == "userdata" then normalized = { message = tostring(info.message) } end + local built = build_error(normalized) + streamer:send_error(tostring(built:kind()), built:message()) + end } + local process_stream = provider.name == "bedrock" and client.process_converse_stream or client.process_stream + assert(process_stream) + local content, stream_err, result = process_stream(response, callbacks) + test.is_nil(content) + if mode == "native" and provider.name ~= "bedrock" then + test.eq(type(stream_err), type(read_error)) + test.eq(stream_err:kind(), read_error:kind()) + test.eq(stream_err:retryable(), read_error:retryable()) + else + test.eq(type(stream_err), "string") + end + assert_clean(stream_err) + if result then assert_clean(result) end + else + test.is_nil(response) + assert_clean(err) + assert_clean(build_error(err):message()) + end + test.eq(#chunks, provider.name == "google" and 2 or 1) + assert_clean(chunks) + end) + end + end + end) + end +end) diff --git a/src/llm/test/util/transport_test.lua b/src/llm/test/util/transport_test.lua index 62eb60f..6317ca6 100644 --- a/src/llm/test/util/transport_test.lua +++ b/src/llm/test/util/transport_test.lua @@ -8,6 +8,80 @@ type Sender = { local function define_tests() describe("Provider Transport", function() + describe("credential redaction", function() + it("preserves native stream error kind and retryability while redacting diagnostics", function() + local err = errors.new({ message = "denied secret-value", kind = errors.UNAVAILABLE, + retryable = true, details = { nested = { message = "secret-value" } } }) + local redacted = transport.redact_error(err, { "secret-value" }) + test.eq(redacted:message(), "denied [REDACTED]") + test.eq(redacted:kind(), err:kind()) + test.eq(redacted:retryable(), err:retryable()) + test.eq(redacted:details().nested.message, "[REDACTED]") + test.eq(err:message(), "denied secret-value") + local wrapped = errors.wrap(err, "request failed") + local redacted_wrapped = transport.redact_error(wrapped, { "secret-value" }) + test.eq(tostring(redacted_wrapped), transport.redact_error(tostring(wrapped), { "secret-value" })) + test.eq(redacted_wrapped:message(), transport.redact_error(wrapped:message(), { "secret-value" })) + test.eq(type(redacted_wrapped), type(wrapped)) + end) + + it("matches literal credentials once with the longest overlap first", function() + local secrets = transport.request_secrets({ + Authorization = "bEaReR a.%+[fixture]long", + ["x-custom"] = "a.%+[fixture]", + }, { ["X-Custom"] = "ignored-config-value" }) + test.eq(transport.redact_error("a.%+[fixture]long / a.%+[fixture]", secrets), + "[REDACTED] / [REDACTED]") + test.eq(transport.redact_error("bEaReR a.%+[fixture]long", secrets), "[REDACTED]") + test.eq(transport.redact_error("[REDACTED] secret", { "secret", "REDACTED" }), + "[[REDACTED]] [REDACTED]") + end) + + it("redacts decoded escaped strings and nested keys without mutating details", function() + local secret = 'quote"slash\\value' + local original = { message = secret, nested = { [secret] = { secret, 7, false } } } + local result = transport.redact_error(original, { secret }) + test.eq(result.message, "[REDACTED]") + test.eq(result.nested["[REDACTED]"][1], "[REDACTED]") + test.eq(result.nested["[REDACTED]"][2], 7) + test.eq(result.nested["[REDACTED]"][3], false) + test.eq(original.message, secret) + test.eq(original.nested[secret][1], secret) + end) + + it("redacts serialized JSON and URL credential forms", function() + local secret = 'quote"slash\\ /+value' + local encoded = 'quote\\"slash\\\\ /+value' + local url_encoded = "quote%22slash%5C%20%2F%2Bvalue" + local form_encoded = "quote%22slash%5C+%2F%2Bvalue" + local diagnostic = secret .. " | " .. encoded .. " | " .. url_encoded + .. " | " .. form_encoded .. " | " .. url_encoded:gsub("%%(%x%x)", string.lower) + test.eq(transport.redact_error(diagnostic, { secret }), + "[REDACTED] | [REDACTED] | [REDACTED] | [REDACTED] | [REDACTED]") + end) + + it("snapshots sent header values and excludes generated protocol headers", function() + local configured = { ["X-Secret"] = "omitted", authorization = "omitted" } + local headers = { ["X-Secret"] = "sent", Authorization = "Bearer token", + ["Content-Type"] = "application/json", Accept = "text/event-stream" } + local secrets = transport.request_secrets(headers, configured) + headers["X-Secret"] = "changed" + test.eq(transport.redact_error("sent token Bearer token omitted changed application/json text/event-stream", secrets), + "[REDACTED] [REDACTED] [REDACTED] omitted changed application/json text/event-stream") + end) + + it("redacts signed authorization credentials and session tokens", function() + local secrets = transport.request_secrets({ + authorization = "AWS4-HMAC-SHA256 Credential=access/date/region/service/aws4_request, SignedHeaders=host, Signature=signature", + ["X-Amz-Security-Token"] = "session-token", + }) + test.eq(transport.redact_error("access signature session-token", secrets), + "[REDACTED] [REDACTED] [REDACTED]") + test.eq(transport.redact_error("unchanged", {}), "unchanged") + test.eq(transport.redact_error("unchanged", nil), "unchanged") + end) + end) + describe("timeout_seconds", function() it("parses seconds and runtime durations", function() for _, case in ipairs({ { 90, 90 }, { "90", 90 }, { "20m", 1200 },