From 30ea48de13c35fd7b6eb0121f50634696c0b33a1 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 18 Nov 2026 07:03:39 +0700 Subject: [PATCH 1/2] refactor: share the AI provider transport and the core driver scaffolding --- .../Core/AI/AIProviderTransport.swift | 134 +++++ .../TablePro/Core/AI/AnthropicProvider.swift | 352 +++++------ .../ChatGPTCodex/ChatGPTCodexProvider.swift | 3 +- apple/TablePro/Core/AI/ChatStreamWire.swift | 97 ++++ apple/TablePro/Core/AI/GeminiProvider.swift | 250 +++----- .../Core/AI/OpenAICompatibleProvider.swift | 546 +++++++----------- .../Core/AI/OpenAIResponsesProvider.swift | 126 ++-- .../Core/AI/ResponsesEventStream.swift | 26 - apple/TablePro/Core/AI/SSEEventStream.swift | 27 +- .../Core/AI/AIProviderTransportTests.swift | 88 +++ .../AI/AnthropicProviderParserTests.swift | 30 +- .../Core/AI/GeminiProviderParserTests.swift | 18 +- .../OpenAICompatibleProviderParserTests.swift | 156 +++-- .../OpenAIResponsesProviderParserTests.swift | 12 +- .../Core/AI/OutputLimitSignalTests.swift | 18 +- .../Core/AI/ProviderStreamFailureTests.swift | 172 +++++- .../Core/AI/SSEEventStreamTests.swift | 80 ++- core/crates/core/src/call_options.rs | 31 + .../src/editor_session_status.rs} | 30 +- core/crates/core/src/lib.rs | 6 +- core/crates/core/src/owned_calls.rs | 9 +- core/crates/core/src/read_emitter.rs | 190 ++++++ core/crates/core/src/write_batch.rs | 41 ++ core/crates/drivers/cassandra/src/editor.rs | 80 +-- .../drivers/cassandra/src/stream_read.rs | 71 +-- .../drivers/cassandra/src/write_batch.rs | 13 +- .../drivers/clickhouse/src/editor_run.rs | 16 +- .../drivers/clickhouse/src/editor_session.rs | 19 +- core/crates/drivers/clickhouse/src/lib.rs | 1 - .../drivers/clickhouse/src/stream_read.rs | 59 +- .../drivers/clickhouse/src/write_batch.rs | 11 +- .../drivers/duckdb/src/editor_session.rs | 13 +- .../crates/drivers/mongodb/src/cursor_rows.rs | 12 +- core/crates/drivers/mongodb/src/editor_run.rs | 11 +- .../drivers/mongodb/src/editor_session.rs | 9 +- core/crates/drivers/mongodb/src/lib.rs | 1 - core/crates/drivers/mongodb/src/rows.rs | 10 +- .../drivers/mongodb/src/session_status.rs | 74 --- .../crates/drivers/mongodb/src/write_batch.rs | 8 +- .../drivers/mssql/src/editor_session.rs | 18 +- core/crates/drivers/mssql/src/stream_read.rs | 91 +-- core/crates/drivers/mssql/src/write_batch.rs | 10 +- .../drivers/mysql/src/editor_session.rs | 16 +- core/crates/drivers/mysql/src/stream_read.rs | 154 ++--- core/crates/drivers/mysql/src/write_batch.rs | 13 +- .../postgres/src/editor/session_status.rs | 34 +- .../drivers/postgres/src/editor/stop_watch.rs | 15 +- .../drivers/postgres/src/stream_read.rs | 152 ++--- core/crates/drivers/redis/src/editor_run.rs | 13 +- .../drivers/redis/src/editor_session.rs | 9 +- core/crates/drivers/redis/src/lib.rs | 1 - core/crates/drivers/redis/src/reply_rows.rs | 8 +- .../drivers/redis/src/session_status.rs | 74 --- core/crates/drivers/sqlite/src/connection.rs | 8 +- core/crates/drivers/sqlite/src/deadline.rs | 8 - .../drivers/sqlite/src/editor_session.rs | 7 +- .../session/src/health/health_monitor.rs | 11 +- 57 files changed, 1648 insertions(+), 1844 deletions(-) create mode 100644 apple/TablePro/Core/AI/AIProviderTransport.swift create mode 100644 apple/TablePro/Core/AI/ChatStreamWire.swift delete mode 100644 apple/TablePro/Core/AI/ResponsesEventStream.swift create mode 100644 apple/TableProTests/Core/AI/AIProviderTransportTests.swift rename core/crates/{drivers/clickhouse/src/session_status.rs => core/src/editor_session_status.rs} (73%) create mode 100644 core/crates/core/src/read_emitter.rs delete mode 100644 core/crates/drivers/mongodb/src/session_status.rs delete mode 100644 core/crates/drivers/redis/src/session_status.rs diff --git a/apple/TablePro/Core/AI/AIProviderTransport.swift b/apple/TablePro/Core/AI/AIProviderTransport.swift new file mode 100644 index 0000000000..5bade7cd7a --- /dev/null +++ b/apple/TablePro/Core/AI/AIProviderTransport.swift @@ -0,0 +1,134 @@ +// +// AIProviderTransport.swift +// TablePro +// + +import Foundation +import TableProHTTP + +struct AIHTTPReply { + let data: Data + let response: HTTPURLResponse + + var statusCode: Int { response.statusCode } +} + +enum AIModelListReply { + case unreachable(any Error) + case notHTTP + case rejected(AIHTTPReply) + // Nil when the body is not JSON or has no array under the key. + case entries([[String: Any]]?) +} + +// The HTTP side every provider shares. A provider configures it and keeps only its wire format. +struct AIProviderTransport: Sendable { + let configuredEndpoint: String + let endpoint: AIEndpoint? + let headers: [String: String] + let forbiddenIsAuthFailure: Bool + let session: URLSession + + init( + endpoint: String, + style: AIEndpointStyle, + headers: [String: String], + forbiddenIsAuthFailure: Bool = false, + session: URLSession + ) { + self.configuredEndpoint = endpoint.trimmingCharacters(in: .whitespacesAndNewlines) + self.endpoint = AIEndpoint(endpoint, style: style) + self.headers = headers + self.forbiddenIsAuthFailure = forbiddenIsAuthFailure + self.session = session + } + + static func bearer(_ apiKey: String?) -> [String: String] { + guard let apiKey, !apiKey.isEmpty else { return [:] } + return ["Authorization": "Bearer \(apiKey)"] + } + + func url(_ resource: String, query: [URLQueryItem] = []) throws -> URL { + guard let url = endpoint?.url(appending: resource, query: query) else { + throw AIProviderError.invalidEndpoint(configuredEndpoint) + } + return url + } + + func get(_ url: URL, timeout: TimeInterval? = AIProvider.modelListTimeout, authenticated: Bool = true) -> URLRequest { + var request = URLRequest(url: url) + request.httpMethod = "GET" + if let timeout { + request.timeoutInterval = timeout + } + if authenticated { + applyHeaders(to: &request) + } + return request + } + + func post(_ url: URL, body: [String: Any]) throws -> URLRequest { + var request = URLRequest(url: url) + request.httpMethod = "POST" + request.setValue("application/json", forHTTPHeaderField: "Content-Type") + applyHeaders(to: &request) + request.httpBody = try JSONSerialization.data(withJSONObject: body) + return request + } + + func stream( + _ wire: Wire, + request: @escaping @Sendable () async throws -> URLRequest + ) -> AsyncThrowingStream { + SSEEventStream.make( + session: session, + treatForbiddenAsAuthFailure: forbiddenIsAuthFailure, + wire: wire, + buildRequest: request + ) + } + + func modelList(at url: URL, key: String, authenticated: Bool = true) async -> AIModelListReply { + let data: Data + let response: URLResponse + do { + (data, response) = try await session.data( + for: get(url, authenticated: authenticated), + delegate: SameOriginRedirects.shared + ) + } catch { + return .unreachable(error) + } + guard let httpResponse = response as? HTTPURLResponse else { return .notHTTP } + guard httpResponse.statusCode == 200 else { + return .rejected(AIHTTPReply(data: data, response: httpResponse)) + } + let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] + return .entries(json?[key] as? [[String: Any]]) + } + + // A rejected key throws; any other answer is the provider's to judge. + func connectionReply(to request: URLRequest) async throws -> AIHTTPReply? { + let (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) + guard let httpResponse = response as? HTTPURLResponse else { return nil } + if httpResponse.statusCode == 401 || (httpResponse.statusCode == 403 && forbiddenIsAuthFailure) { + throw AIProviderError.authenticationFailed("") + } + return AIHTTPReply(data: data, response: httpResponse) + } + + func httpError(_ reply: AIHTTPReply, url: URL?) -> AIProviderError { + AIProviderError.mapHTTPError( + statusCode: reply.statusCode, + body: String(data: reply.data, encoding: .utf8) ?? "", + treatForbiddenAsAuthFailure: forbiddenIsAuthFailure, + requestURL: url + ) + } + + private func applyHeaders(to request: inout URLRequest) { + for (field, value) in headers { + request.setValue(value, forHTTPHeaderField: field) + } + } +} diff --git a/apple/TablePro/Core/AI/AnthropicProvider.swift b/apple/TablePro/Core/AI/AnthropicProvider.swift index 7106932e2f..699164ef46 100644 --- a/apple/TablePro/Core/AI/AnthropicProvider.swift +++ b/apple/TablePro/Core/AI/AnthropicProvider.swift @@ -5,20 +5,16 @@ import Foundation import os -import TableProHTTP import TableProMCP final class AnthropicProvider: ChatTransport { private static let logger = Logger(subsystem: "com.TablePro", category: "AnthropicProvider") - private let endpoint: String - private let resolvedEndpoint: AIEndpoint? - private let apiKey: String + private let transport: AIProviderTransport private let model: String private let maxOutputTokens: Int private let configuredEffort: ReasoningEffort? private let providerID: UUID? - private let session: URLSession init( endpoint: String, @@ -29,84 +25,52 @@ final class AnthropicProvider: ChatTransport { providerID: UUID? = nil, session: URLSession = URLSession(configuration: .ephemeral) ) { - self.endpoint = endpoint.trimmingCharacters(in: .whitespacesAndNewlines) - self.resolvedEndpoint = AIEndpoint(endpoint, style: .messages) - self.apiKey = apiKey.trimmingCharacters(in: .whitespacesAndNewlines) + self.transport = AIProviderTransport( + endpoint: endpoint, + style: .messages, + headers: [ + "x-api-key": apiKey.trimmingCharacters(in: .whitespacesAndNewlines), + "anthropic-version": "2023-06-01" + ], + session: session + ) self.model = model.trimmingCharacters(in: .whitespacesAndNewlines) self.maxOutputTokens = maxOutputTokens self.configuredEffort = reasoningEffort self.providerID = providerID - self.session = session - } - - private func requestURL(_ resource: String) throws -> URL { - guard let url = resolvedEndpoint?.url(appending: resource) else { - throw AIProviderError.invalidEndpoint(endpoint) - } - return url } func streamChat( turns: [ChatTurnWire], options: ChatTransportOptions ) -> AsyncThrowingStream { - SSEEventStream.make( - session: session, - buildRequest: { [self] in - try buildMessagesRequest( - turns: turns, - options: options, - effort: options.reasoningEffort ?? configuredEffort - ) - }, - decodeLine: { Self.decodeStreamLine($0) }, - makeState: { AnthropicStreamState() }, - parse: { try Self.parseChunk($0, state: &$1) }, - finalEvents: { state in state.finalUsageEvent().map { [$0] } ?? [] } - ) + transport.stream(AnthropicStreamWire()) { [self] in + try buildMessagesRequest( + turns: turns, + options: options, + effort: options.reasoningEffort ?? configuredEffort + ) + } } func fetchAvailableModels() async throws -> [AIModelInfo] { - let url = try requestURL(AIEndpointStyle.messages.modelsResource) - - var request = URLRequest(url: url) - request.httpMethod = "GET" - request.timeoutInterval = AIProvider.modelListTimeout - request.setValue(apiKey, forHTTPHeaderField: "x-api-key") - request.setValue("2023-06-01", forHTTPHeaderField: "anthropic-version") - - let data: Data - let response: URLResponse - do { - (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) - } catch { + let url = try transport.url(AIEndpointStyle.messages.modelsResource) + switch await transport.modelList(at: url, key: "data") { + case .unreachable(let error): Self.logger.warning("Anthropic model fetch failed; using known models: \(error.publicLogShape, privacy: .public)") return Self.offlineModels - } - - guard let httpResponse = response as? HTTPURLResponse else { + case .notHTTP: Self.logger.warning("Anthropic model fetch returned no HTTP response; using known models") return Self.offlineModels - } - - guard httpResponse.statusCode == 200 else { - let body = String(data: data, encoding: .utf8) ?? "" - throw AIProviderError.mapHTTPError( - statusCode: httpResponse.statusCode, - body: body, - requestURL: url - ) - } - - guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any], - let models = json["data"] as? [[String: Any]] - else { + case .rejected(let reply): + throw transport.httpError(reply, url: url) + case .entries(nil): Self.logger.warning("Anthropic model fetch returned unexpected response; using known models") return Self.offlineModels + case .entries(let models?): + let fetched = models.compactMap(Self.decodeModel(_:)) + return fetched.isEmpty ? Self.offlineModels : fetched } - - let fetched = models.compactMap(Self.decodeModel(_:)) - return fetched.isEmpty ? Self.offlineModels : fetched } static func decodeModel(_ json: [String: Any]) -> AIModelInfo? { @@ -185,25 +149,11 @@ final class AnthropicProvider: ChatTransport { stream: false, effort: nil ) - - let (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) - - guard let httpResponse = response as? HTTPURLResponse else { - return false + guard let reply = try await transport.connectionReply(to: request) else { return false } + guard reply.statusCode == 200 || reply.statusCode == 400 else { + throw transport.httpError(reply, url: request.url) } - - let statusCode = httpResponse.statusCode - - if statusCode == 200 || statusCode == 400 { - return true - } - - if statusCode == 401 { - throw AIProviderError.authenticationFailed("") - } - - let body = String(data: data, encoding: .utf8) ?? "" - throw AIProviderError.mapHTTPError(statusCode: statusCode, body: body, requestURL: request.url) + return true } func buildMessagesRequest( @@ -212,13 +162,7 @@ final class AnthropicProvider: ChatTransport { stream: Bool = true, effort: ReasoningEffort? ) throws -> URLRequest { - let url = try requestURL(AIEndpointStyle.messages.chatResource(model: options.model)) - - var request = URLRequest(url: url) - request.httpMethod = "POST" - request.setValue("application/json", forHTTPHeaderField: "Content-Type") - request.setValue(apiKey, forHTTPHeaderField: "x-api-key") - request.setValue("2023-06-01", forHTTPHeaderField: "anthropic-version") + let url = try transport.url(AIEndpointStyle.messages.chatResource(model: options.model)) let resolvedMaxTokens = options.maxOutputTokens ?? effort?.autoScaledMaxOutputTokens @@ -233,8 +177,7 @@ final class AnthropicProvider: ChatTransport { liveReasoning: AIModelCatalog.shared.fetchedInfo(providerID: providerID, modelID: options.model)?.reasoning ) - request.httpBody = try JSONSerialization.data(withJSONObject: body) - return request + return try transport.post(url, body: body) } static func makeRequestBody( @@ -306,19 +249,101 @@ final class AnthropicProvider: ChatTransport { } } - static func decodeStreamLine(_ line: String) -> [String: Any]? { - guard let jsonString = SSEEventStream.dataPayload(line), - jsonString != "[DONE]", - let data = jsonString.data(using: .utf8), - let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] - else { return nil } - return json + static func encodeToolSpec(_ spec: ChatToolSpec) throws -> [String: Any] { + [ + "name": spec.name, + "description": spec.description, + "input_schema": try spec.inputSchema.jsonObject() + ] + } + + static func encodeTurn(_ turn: ChatTurnWire) throws -> [String: Any]? { + let blocks = turn.blocks + let needsTypedBlocks = blocks.contains { block in + switch block.kind { + case .toolUse, .toolResult, .reasoning, .image, .sqlWalkthrough: + return true + case .text, .attachment: + return false + } + } + + if needsTypedBlocks { + let encoded = try blocks.compactMap { try encodeBlock($0) } + guard !encoded.isEmpty else { return nil } + return ["role": turn.role.rawValue, "content": encoded] + } + + let text = turn.plainText + guard !text.isEmpty else { return nil } + return ["role": turn.role.rawValue, "content": text] } - static func parseChunk( - _ json: [String: Any], - state: inout AnthropicStreamState - ) throws -> [ChatStreamEvent] { + static func encodeBlock(_ block: ChatContentBlockWire) throws -> [String: Any]? { + switch block.kind { + case .text(let text): + guard !text.isEmpty else { return nil } + return ["type": "text", "text": text] + case .sqlWalkthrough(let walkthrough): + let text = walkthrough.transcriptText + guard !text.isEmpty else { return nil } + return ["type": "text", "text": text] + case .toolUse(let toolUse): + return [ + "type": "tool_use", + "id": toolUse.id, + "name": toolUse.name, + "input": try toolUse.input.jsonObject() + ] + case .toolResult(let result): + var encoded: [String: Any] = [ + "type": "tool_result", + "tool_use_id": result.toolUseId, + "content": result.content + ] + if result.isError { + encoded["is_error"] = true + } + return encoded + case .attachment: + return nil + case .reasoning(let reasoning): + guard let opaque = reasoning.opaque, opaque.kind == .anthropicSignature else { return nil } + if opaque.blockType == "redacted_thinking" { + return ["type": "redacted_thinking", "data": opaque.value] + } + return [ + "type": "thinking", + "thinking": reasoning.text ?? "", + "signature": opaque.value + ] + case .image(let input): + switch input.source { + case .cacheFile(let filename, let mediaType): + guard let data = AIImageCache.shared.read(filename: filename) else { return nil } + return [ + "type": "image", + "source": [ + "type": "base64", + "media_type": mediaType, + "data": data.base64EncodedString() + ] as [String: Any] + ] + case .remoteURL(let url, _): + return [ + "type": "image", + "source": [ + "type": "url", + "url": url.absoluteString + ] as [String: Any] + ] + } + } + } +} + +struct AnthropicStreamWire: ChatStreamWire { + func parse(_ json: [String: Any], state: inout AnthropicStreamState) -> [ChatStreamEvent] { guard let type = json["type"] as? String else { return [] } switch type { case "content_block_start": @@ -329,8 +354,7 @@ final class AnthropicProvider: ChatTransport { case "tool_use": guard let blockId = block["id"] as? String, let blockName = block["name"] as? String else { return [] } - state.toolUseIdsByIndex[index] = blockId - return [.toolUseStart(id: blockId, name: blockName)] + return [state.toolCalls.start(index, id: blockId, name: blockName)].compactMap { $0 } case "thinking", "redacted_thinking": let synthID = "thinking_\(UUID().uuidString.prefix(8))" let resolvedType = blockType ?? "thinking" @@ -350,7 +374,7 @@ final class AnthropicProvider: ChatTransport { let deltaType = delta["type"] as? String if deltaType == "input_json_delta" { guard let index = json["index"] as? Int, - let id = state.toolUseIdsByIndex[index], + let id = state.toolCalls.id(for: index), let partial = delta["partial_json"] as? String else { return [] } return [.toolUseDelta(id: id, inputJSONDelta: partial)] @@ -374,8 +398,8 @@ final class AnthropicProvider: ChatTransport { return [] case "content_block_stop": guard let index = json["index"] as? Int else { return [] } - if let toolID = state.toolUseIdsByIndex.removeValue(forKey: index) { - return [.toolUseEnd(id: toolID)] + if let toolEnd = state.toolCalls.end(index) { + return [toolEnd] } if let thinkingID = state.thinkingIdsByIndex.removeValue(forKey: index) { let blockType = state.thinkingTypeByIndex.removeValue(forKey: index) ?? "thinking" @@ -405,7 +429,11 @@ final class AnthropicProvider: ChatTransport { let tokens = usage["output_tokens"] as? Int { state.outputTokens = tokens } - switch (json["delta"] as? [String: Any])?["stop_reason"] as? String { + let stopReason = (json["delta"] as? [String: Any])?["stop_reason"] as? String + if let stopReason, !stopReason.isEmpty { + state.receivedOutput = true + } + switch stopReason { case "max_tokens": return [.outputLimitReached(.outputTokens)] case "model_context_window_exceeded": @@ -413,122 +441,22 @@ final class AnthropicProvider: ChatTransport { default: return [] } - case "error": - if let errorObj = json["error"] as? [String: Any], - let message = errorObj["message"] as? String { - throw AIProviderError.streamingFailed(message) - } + case "message_stop": + state.receivedOutput = true return [] default: return [] } } - - static func encodeToolSpec(_ spec: ChatToolSpec) throws -> [String: Any] { - [ - "name": spec.name, - "description": spec.description, - "input_schema": try spec.inputSchema.jsonObject() - ] - } - - static func encodeTurn(_ turn: ChatTurnWire) throws -> [String: Any]? { - let blocks = turn.blocks - let needsTypedBlocks = blocks.contains { block in - switch block.kind { - case .toolUse, .toolResult, .reasoning, .image, .sqlWalkthrough: - return true - case .text, .attachment: - return false - } - } - - if needsTypedBlocks { - let encoded = try blocks.compactMap { try encodeBlock($0) } - guard !encoded.isEmpty else { return nil } - return ["role": turn.role.rawValue, "content": encoded] - } - - let text = turn.plainText - guard !text.isEmpty else { return nil } - return ["role": turn.role.rawValue, "content": text] - } - - static func encodeBlock(_ block: ChatContentBlockWire) throws -> [String: Any]? { - switch block.kind { - case .text(let text): - guard !text.isEmpty else { return nil } - return ["type": "text", "text": text] - case .sqlWalkthrough(let walkthrough): - let text = walkthrough.transcriptText - guard !text.isEmpty else { return nil } - return ["type": "text", "text": text] - case .toolUse(let toolUse): - return [ - "type": "tool_use", - "id": toolUse.id, - "name": toolUse.name, - "input": try toolUse.input.jsonObject() - ] - case .toolResult(let result): - var encoded: [String: Any] = [ - "type": "tool_result", - "tool_use_id": result.toolUseId, - "content": result.content - ] - if result.isError { - encoded["is_error"] = true - } - return encoded - case .attachment: - return nil - case .reasoning(let reasoning): - guard let opaque = reasoning.opaque, opaque.kind == .anthropicSignature else { return nil } - if opaque.blockType == "redacted_thinking" { - return ["type": "redacted_thinking", "data": opaque.value] - } - return [ - "type": "thinking", - "thinking": reasoning.text ?? "", - "signature": opaque.value - ] - case .image(let input): - switch input.source { - case .cacheFile(let filename, let mediaType): - guard let data = AIImageCache.shared.read(filename: filename) else { return nil } - return [ - "type": "image", - "source": [ - "type": "base64", - "media_type": mediaType, - "data": data.base64EncodedString() - ] as [String: Any] - ] - case .remoteURL(let url, _): - return [ - "type": "image", - "source": [ - "type": "url", - "url": url.absoluteString - ] as [String: Any] - ] - } - } - } } -/// Mutable state carried across `AnthropicProvider.parseChunk` calls. -struct AnthropicStreamState { +struct AnthropicStreamState: ChatStreamState { var inputTokens: Int = 0 var outputTokens: Int = 0 - var toolUseIdsByIndex: [Int: String] = [:] + var receivedOutput = false + var toolCalls = ToolCallTracker() var thinkingIdsByIndex: [Int: String] = [:] var thinkingTypeByIndex: [Int: String] = [:] var thinkingSignatureByIndex: [Int: String] = [:] var thinkingRedactedDataByIndex: [Int: String] = [:] - - func finalUsageEvent() -> ChatStreamEvent? { - guard inputTokens > 0 || outputTokens > 0 else { return nil } - return .usage(AITokenUsage(inputTokens: inputTokens, outputTokens: outputTokens)) - } } diff --git a/apple/TablePro/Core/AI/ChatGPTCodex/ChatGPTCodexProvider.swift b/apple/TablePro/Core/AI/ChatGPTCodex/ChatGPTCodexProvider.swift index bb8089ad2b..b6ae71d521 100644 --- a/apple/TablePro/Core/AI/ChatGPTCodex/ChatGPTCodexProvider.swift +++ b/apple/TablePro/Core/AI/ChatGPTCodex/ChatGPTCodexProvider.swift @@ -28,9 +28,10 @@ final class ChatGPTCodexProvider: ChatTransport { options: ChatTransportOptions ) -> AsyncThrowingStream { let sessionID = UUID().uuidString - return ResponsesEventStream.make( + return SSEEventStream.make( session: session, treatForbiddenAsAuthFailure: true, + wire: ResponsesStreamWire(), buildRequest: { [self] in try await buildRequest(turns: turns, options: options, stream: true, sessionID: sessionID) }, diff --git a/apple/TablePro/Core/AI/ChatStreamWire.swift b/apple/TablePro/Core/AI/ChatStreamWire.swift new file mode 100644 index 0000000000..658e3718f3 --- /dev/null +++ b/apple/TablePro/Core/AI/ChatStreamWire.swift @@ -0,0 +1,97 @@ +// +// ChatStreamWire.swift +// TablePro +// + +import Foundation + +protocol ChatStreamState { + init() + var inputTokens: Int { get set } + var outputTokens: Int { get set } + // Set once the provider sent anything, or said the response is over. + var receivedOutput: Bool { get set } +} + +extension ChatStreamState { + func finalUsageEvent() -> ChatStreamEvent? { + guard inputTokens > 0 || outputTokens > 0 else { return nil } + return .usage(AITokenUsage(inputTokens: inputTokens, outputTokens: outputTokens)) + } +} + +// One provider's response stream. `events(from:state:)` and `finalEvents(_:)` are what every provider runs around it. +protocol ChatStreamWire: Sendable { + associatedtype State: ChatStreamState + + func decodeLine(_ line: String) -> [String: Any]? + func parse(_ json: [String: Any], state: inout State) throws -> [ChatStreamEvent] + func closingEvents(_ state: inout State) -> [ChatStreamEvent] +} + +extension ChatStreamWire { + func decodeLine(_ line: String) -> [String: Any]? { + SSEEventStream.jsonPayload(line) + } + + func closingEvents(_ state: inout State) -> [ChatStreamEvent] { + [] + } + + func events(from json: [String: Any], state: inout State) throws -> [ChatStreamEvent] { + if let error = AIProviderError.streamError(in: json) { throw error } + let events = try parse(json, state: &state) + if !events.isEmpty { + state.receivedOutput = true + } + return events + } + + // A base URL that answers 200 with a web page decodes to nothing, which would otherwise read as an empty reply. + func finalEvents(_ state: State) throws -> [ChatStreamEvent] { + guard state.receivedOutput else { + throw AIProviderError.streamingFailed( + String(localized: "The provider ended the response without sending any content.") + ) + } + var state = state + return closingEvents(&state) + [state.finalUsageEvent()].compactMap { $0 } + } +} + +struct ToolCallTracker { + private var ids: [Key: String] = [:] + private var order: [Key] = [] + + var isEmpty: Bool { ids.isEmpty } + + func id(for key: Key) -> String? { + ids[key] + } + + // A second start for a call that is still open opens nothing new. + mutating func start( + _ key: Key, + id: String, + name: String, + providerMetadata: [String: String]? = nil + ) -> ChatStreamEvent? { + guard ids[key] == nil else { return nil } + ids[key] = id + order.append(key) + return .toolUseStart(id: id, name: name, providerMetadata: providerMetadata) + } + + mutating func end(_ key: Key) -> ChatStreamEvent? { + guard let id = ids.removeValue(forKey: key) else { return nil } + order.removeAll { $0 == key } + return .toolUseEnd(id: id) + } + + mutating func endAll() -> [ChatStreamEvent] { + let events = order.compactMap { ids[$0] }.map { ChatStreamEvent.toolUseEnd(id: $0) } + ids.removeAll() + order.removeAll() + return events + } +} diff --git a/apple/TablePro/Core/AI/GeminiProvider.swift b/apple/TablePro/Core/AI/GeminiProvider.swift index b2197bd9cd..596858ac89 100644 --- a/apple/TablePro/Core/AI/GeminiProvider.swift +++ b/apple/TablePro/Core/AI/GeminiProvider.swift @@ -5,17 +5,13 @@ import Foundation import os -import TableProHTTP import TableProMCP final class GeminiProvider: ChatTransport { private static let logger = Logger(subsystem: "com.TablePro", category: "GeminiProvider") - private let endpoint: String - private let resolvedEndpoint: AIEndpoint? - private let apiKey: String + private let transport: AIProviderTransport private let maxOutputTokens: Int - private let session: URLSession init( endpoint: String, @@ -23,36 +19,23 @@ final class GeminiProvider: ChatTransport { maxOutputTokens: Int = 8_192, session: URLSession = URLSession(configuration: .ephemeral) ) { - self.endpoint = endpoint.trimmingCharacters(in: .whitespacesAndNewlines) - self.resolvedEndpoint = AIEndpoint(endpoint, style: .gemini) - self.apiKey = apiKey.trimmingCharacters(in: .whitespacesAndNewlines) + self.transport = AIProviderTransport( + endpoint: endpoint, + style: .gemini, + headers: ["x-goog-api-key": apiKey.trimmingCharacters(in: .whitespacesAndNewlines)], + forbiddenIsAuthFailure: true, + session: session + ) self.maxOutputTokens = maxOutputTokens - self.session = session - } - - private func requestURL(_ resource: String, query: [URLQueryItem] = []) throws -> URL { - guard let url = resolvedEndpoint?.url(appending: resource, query: query) else { - throw AIProviderError.invalidEndpoint(endpoint) - } - return url } func streamChat( turns: [ChatTurnWire], options: ChatTransportOptions ) -> AsyncThrowingStream { - SSEEventStream.make( - session: session, - treatForbiddenAsAuthFailure: true, - buildRequest: { [self] in try buildStreamRequest(turns: turns, options: options) }, - decodeLine: { Self.decodeStreamLine($0) }, - makeState: { GeminiStreamState() }, - parse: { json, state in - if let error = AIProviderError.streamError(in: json) { throw error } - return Self.parseChunk(json, state: &state, idGenerator: { UUID().uuidString }) - }, - finalEvents: { state in state.finalUsageEvent().map { [$0] } ?? [] } - ) + transport.stream(GeminiStreamWire()) { [self] in + try buildStreamRequest(turns: turns, options: options) + } } private static let offlineModels: [AIModelInfo] = [ @@ -71,46 +54,23 @@ final class GeminiProvider: ChatTransport { } func fetchAvailableModels() async throws -> [AIModelInfo] { - let url = try requestURL(AIEndpointStyle.gemini.modelsResource) - - var request = URLRequest(url: url) - request.httpMethod = "GET" - request.timeoutInterval = AIProvider.modelListTimeout - request.setValue(apiKey, forHTTPHeaderField: "x-goog-api-key") - - let data: Data - let response: URLResponse - do { - (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) - } catch { + let url = try transport.url(AIEndpointStyle.gemini.modelsResource) + switch await transport.modelList(at: url, key: "models") { + case .unreachable(let error): Self.logger.warning("Gemini model fetch failed; using known models: \(error.publicLogShape, privacy: .public)") return Self.offlineModels - } - - guard let httpResponse = response as? HTTPURLResponse else { + case .notHTTP: Self.logger.warning("Gemini model fetch returned no HTTP response; using known models") return Self.offlineModels - } - - guard httpResponse.statusCode == 200 else { - let body = String(data: data, encoding: .utf8) ?? "" - throw AIProviderError.mapHTTPError( - statusCode: httpResponse.statusCode, - body: body, - treatForbiddenAsAuthFailure: true, - requestURL: url - ) - } - - guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any], - let models = json["models"] as? [[String: Any]] - else { + case .rejected(let reply): + throw transport.httpError(reply, url: url) + case .entries(nil): Self.logger.warning("Gemini model fetch returned unexpected response; using known models") return Self.offlineModels + case .entries(let models?): + let fetched = models.compactMap(Self.decodeModel(_:)) + return fetched.isEmpty ? Self.offlineModels : fetched } - - let fetched = models.compactMap(Self.decodeModel(_:)) - return fetched.isEmpty ? Self.offlineModels : fetched } static func decodeModel(_ json: [String: Any]) -> AIModelInfo? { @@ -135,34 +95,13 @@ final class GeminiProvider: ChatTransport { } func testConnection() async throws -> Bool { - let url = try requestURL(AIEndpointStyle.gemini.modelsResource) - - var request = URLRequest(url: url) - request.httpMethod = "GET" - request.setValue(apiKey, forHTTPHeaderField: "x-goog-api-key") - - let (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) - - guard let httpResponse = response as? HTTPURLResponse else { + let url = try transport.url(AIEndpointStyle.gemini.modelsResource) + guard let reply = try await transport.connectionReply(to: transport.get(url, timeout: nil)) else { return false } - - let statusCode = httpResponse.statusCode - - if statusCode == 401 || statusCode == 403 { - throw AIProviderError.authenticationFailed("") - } - - guard statusCode == 200 else { - let body = String(data: data, encoding: .utf8) ?? "" - throw AIProviderError.mapHTTPError( - statusCode: statusCode, - body: body, - treatForbiddenAsAuthFailure: true, - requestURL: url - ) + guard reply.statusCode == 200 else { + throw transport.httpError(reply, url: url) } - return true } @@ -171,12 +110,7 @@ final class GeminiProvider: ChatTransport { options: ChatTransportOptions ) throws -> URLRequest { let style = AIEndpointStyle.gemini - let url = try requestURL(style.chatResource(model: options.model), query: style.chatQuery) - - var request = URLRequest(url: url) - request.httpMethod = "POST" - request.setValue("application/json", forHTTPHeaderField: "Content-Type") - request.setValue(apiKey, forHTTPHeaderField: "x-goog-api-key") + let url = try transport.url(style.chatResource(model: options.model), query: style.chatQuery) var body: [String: Any] = [ "generationConfig": ["maxOutputTokens": options.maxOutputTokens ?? maxOutputTokens] @@ -201,8 +135,7 @@ final class GeminiProvider: ChatTransport { body["contents"] = encodeContents(turns: turns) - request.httpBody = try JSONSerialization.data(withJSONObject: body) - return request + return try transport.post(url, body: body) } func encodeContents(turns: [ChatTurnWire]) -> [[String: Any]] { @@ -276,66 +209,6 @@ final class GeminiProvider: ChatTransport { return nil } - /// Decodes one Gemini SSE line. Returns nil for non-data lines. - static func decodeStreamLine(_ line: String) -> [String: Any]? { - guard let jsonString = SSEEventStream.dataPayload(line), - let data = jsonString.data(using: .utf8), - let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] - else { return nil } - return json - } - - /// Translate a single Gemini chunk to events. - /// - /// Gemini does not provide tool-call ids on `functionCall` parts, so we - /// synthesize one per call. `idGenerator` is injected so tests can pin the - /// synthetic id to a stable value; production passes `{ UUID().uuidString }`. - /// Each call to `idGenerator()` returns a fresh id, so multiple - /// `functionCall` parts in one chunk get distinct ids in production. - static func parseChunk( - _ json: [String: Any], - state: inout GeminiStreamState, - idGenerator: () -> String - ) -> [ChatStreamEvent] { - var events: [ChatStreamEvent] = [] - if let candidates = json["candidates"] as? [[String: Any]], - let firstCandidate = candidates.first, - let content = firstCandidate["content"] as? [String: Any], - let parts = content["parts"] as? [[String: Any]] { - for part in parts { - if let text = part["text"] as? String, !text.isEmpty { - events.append(.textDelta(text)) - } - if let functionCall = part["functionCall"] as? [String: Any], - let name = functionCall["name"] as? String { - let id = idGenerator() - let argsObject = functionCall["args"] ?? [String: Any]() - let argsString = encodeArgsToJSONString(argsObject) - var metadata: [String: String]? - if let signature = part["thoughtSignature"] as? String, !signature.isEmpty { - metadata = ["thoughtSignature": signature] - } - events.append(.toolUseStart(id: id, name: name, providerMetadata: metadata)) - events.append(.toolUseDelta(id: id, inputJSONDelta: argsString)) - events.append(.toolUseEnd(id: id)) - } - } - } - if let candidates = json["candidates"] as? [[String: Any]], - candidates.first?["finishReason"] as? String == "MAX_TOKENS" { - events.append(.outputLimitReached(.outputTokens)) - } - if let usageMetadata = json["usageMetadata"] as? [String: Any] { - if let prompt = usageMetadata["promptTokenCount"] as? Int { - state.inputTokens = prompt - } - if let candidates = usageMetadata["candidatesTokenCount"] as? Int { - state.outputTokens = candidates - } - } - return events - } - static func encodeArgsToJSONString(_ args: Any) -> String { guard JSONSerialization.isValidJSONObject(args) else { Self.logger.warning("Gemini functionCall args was not a valid JSON object; falling back to empty input") @@ -350,12 +223,7 @@ final class GeminiProvider: ChatTransport { } } - // MARK: - Schema Sanitization - - /// Strip JSON Schema features Gemini's `function_declarations` API rejects. - /// Removes `additionalProperties` keys at any depth. Rewrites optional fields - /// expressed as `type: ["X", "null"]` to `type: "X"` plus `nullable: true`, - /// which is the form Gemini accepts. + // Gemini's function declarations reject `additionalProperties` and a `type` array; nullable is its own flag there. static func sanitizeSchemaForGemini(_ schema: JsonValue) -> JsonValue { switch schema { case .object(let fields): @@ -402,13 +270,61 @@ final class GeminiProvider: ChatTransport { } } -/// Mutable state carried across `GeminiProvider.parseChunk` calls. -struct GeminiStreamState { - var inputTokens: Int = 0 - var outputTokens: Int = 0 +struct GeminiStreamWire: ChatStreamWire { + // Gemini sends no tool-call ids, so each call gets one made here. + var idGenerator: @Sendable () -> String = { UUID().uuidString } - func finalUsageEvent() -> ChatStreamEvent? { - guard inputTokens > 0 || outputTokens > 0 else { return nil } - return .usage(AITokenUsage(inputTokens: inputTokens, outputTokens: outputTokens)) + func parse(_ json: [String: Any], state: inout GeminiStreamState) -> [ChatStreamEvent] { + var events: [ChatStreamEvent] = [] + if let candidates = json["candidates"] as? [[String: Any]], + let firstCandidate = candidates.first, + let content = firstCandidate["content"] as? [String: Any], + let parts = content["parts"] as? [[String: Any]] { + for part in parts { + if let text = part["text"] as? String, !text.isEmpty { + events.append(.textDelta(text)) + } + if let functionCall = part["functionCall"] as? [String: Any], + let name = functionCall["name"] as? String { + let id = idGenerator() + let argsObject = functionCall["args"] ?? [String: Any]() + let argsString = GeminiProvider.encodeArgsToJSONString(argsObject) + var metadata: [String: String]? + if let signature = part["thoughtSignature"] as? String, !signature.isEmpty { + metadata = ["thoughtSignature": signature] + } + events.append(.toolUseStart(id: id, name: name, providerMetadata: metadata)) + events.append(.toolUseDelta(id: id, inputJSONDelta: argsString)) + events.append(.toolUseEnd(id: id)) + } + } + } + if let finishReason = (json["candidates"] as? [[String: Any]])?.first?["finishReason"] as? String, + !finishReason.isEmpty { + state.receivedOutput = true + if finishReason == "MAX_TOKENS" { + events.append(.outputLimitReached(.outputTokens)) + } + } + // A blocked prompt is answered with its reason and no candidates, and that is the whole reply. + if let blockReason = (json["promptFeedback"] as? [String: Any])?["blockReason"] as? String, + !blockReason.isEmpty { + state.receivedOutput = true + } + if let usageMetadata = json["usageMetadata"] as? [String: Any] { + if let prompt = usageMetadata["promptTokenCount"] as? Int { + state.inputTokens = prompt + } + if let candidates = usageMetadata["candidatesTokenCount"] as? Int { + state.outputTokens = candidates + } + } + return events } } + +struct GeminiStreamState: ChatStreamState { + var inputTokens: Int = 0 + var outputTokens: Int = 0 + var receivedOutput = false +} diff --git a/apple/TablePro/Core/AI/OpenAICompatibleProvider.swift b/apple/TablePro/Core/AI/OpenAICompatibleProvider.swift index 03e7c264ec..792106d069 100644 --- a/apple/TablePro/Core/AI/OpenAICompatibleProvider.swift +++ b/apple/TablePro/Core/AI/OpenAICompatibleProvider.swift @@ -5,7 +5,6 @@ import Foundation import os -import TableProHTTP import TableProMCP final class OpenAICompatibleProvider: ChatTransport { @@ -14,18 +13,14 @@ final class OpenAICompatibleProvider: ChatTransport { category: "OpenAICompatibleProvider" ) - private let endpoint: String + private let transport: AIProviderTransport private let style: AIEndpointStyle - private let resolvedEndpoint: AIEndpoint? - private let apiKey: String? private let providerType: AIProviderType private let model: String private let maxOutputTokens: Int? - private let treatsForbiddenAsAuthFailure: Bool private let modelIDs: AIModelIDFilter private let providerID: UUID? private let catalog: AIModelCatalog - private let session: URLSession private var testConnectionModel: String { model.isEmpty ? "test" : model } @@ -43,18 +38,20 @@ final class OpenAICompatibleProvider: ChatTransport { session: URLSession = URLSession(configuration: .ephemeral) ) { let style = providerType.endpointStyle - self.endpoint = endpoint.trimmingCharacters(in: .whitespacesAndNewlines) + self.transport = AIProviderTransport( + endpoint: endpoint, + style: style, + headers: AIProviderTransport.bearer(apiKey?.trimmingCharacters(in: .whitespacesAndNewlines)), + forbiddenIsAuthFailure: treatsForbiddenAsAuthFailure, + session: session + ) self.style = style - self.resolvedEndpoint = AIEndpoint(endpoint, style: style) - self.apiKey = apiKey?.trimmingCharacters(in: .whitespacesAndNewlines) self.providerType = providerType self.model = model.trimmingCharacters(in: .whitespacesAndNewlines) self.maxOutputTokens = maxOutputTokens - self.treatsForbiddenAsAuthFailure = treatsForbiddenAsAuthFailure self.modelIDs = modelIDs self.providerID = providerID self.catalog = catalog - self.session = session } convenience init( @@ -75,194 +72,13 @@ final class OpenAICompatibleProvider: ChatTransport { ) } - private func requestURL(_ resource: String) throws -> URL { - guard let url = resolvedEndpoint?.url(appending: resource) else { - throw AIProviderError.invalidEndpoint(endpoint) - } - return url - } - func streamChat( turns: [ChatTurnWire], options: ChatTransportOptions ) -> AsyncThrowingStream { - let providerType = self.providerType - return SSEEventStream.make( - session: session, - treatForbiddenAsAuthFailure: treatsForbiddenAsAuthFailure, - buildRequest: { [self] in try buildChatCompletionRequest(turns: turns, options: options) }, - decodeLine: { Self.decodeStreamLine($0, providerType: providerType) }, - makeState: { OpenAIStreamState() }, - parse: { try Self.streamEvents(from: $0, state: &$1) }, - finalEvents: { try Self.finalStreamEvents($0) } - ) - } - - static func streamEvents( - from json: [String: Any], - state: inout OpenAIStreamState - ) throws -> [ChatStreamEvent] { - if let error = AIProviderError.streamError(in: json) { throw error } - return parseChunk(json, state: &state).events - } - - static func finalStreamEvents(_ state: OpenAIStreamState) throws -> [ChatStreamEvent] { - guard state.receivedOutput else { - throw AIProviderError.streamingFailed( - String(localized: "The provider ended the response without sending any content.") - ) + transport.stream(ChatCompletionsStreamWire(ollama: providerType == .ollama)) { [self] in + try buildChatCompletionRequest(turns: turns, options: options) } - var state = state - return [state.flushReasoningEnd(), state.finalUsageEvent()].compactMap { $0 } - } - - static func decodeStreamLine(_ line: String, providerType: AIProviderType) -> [String: Any]? { - let jsonString: String - if providerType == .ollama { - guard !line.isEmpty else { return nil } - jsonString = line - } else { - guard let payload = SSEEventStream.dataPayload(line), payload != "[DONE]" else { return nil } - jsonString = payload - } - guard let data = jsonString.data(using: .utf8), - let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] - else { return nil } - return json - } - - static func parseChunk( - _ json: [String: Any], - state: inout OpenAIStreamState - ) -> (events: [ChatStreamEvent], shouldBreak: Bool) { - var events: [ChatStreamEvent] = [] - let choices = json["choices"] as? [[String: Any]] - let firstChoice = choices?.first - let delta = firstChoice?["delta"] as? [String: Any] - - if let delta, let reasoningContent = delta["reasoning_content"] as? String, !reasoningContent.isEmpty { - let reasoningID: String - if let existing = state.reasoningBlockID { - reasoningID = existing - } else { - let newID = "reasoning_\(UUID().uuidString.prefix(8))" - state.reasoningBlockID = newID - events.append(.reasoningStart(id: newID)) - reasoningID = newID - } - events.append(.reasoningDelta(id: reasoningID, text: reasoningContent)) - } - - if let delta, let content = delta["content"] as? String, !content.isEmpty { - events.append(.textDelta(content)) - } else if let message = json["message"] as? [String: Any], - let content = message["content"] as? String, - !content.isEmpty { - events.append(.textDelta(content)) - } - - if let delta, let toolCalls = delta["tool_calls"] as? [[String: Any]] { - events.append(contentsOf: handleToolCallDeltas(toolCalls, state: &state)) - } else if let message = json["message"] as? [String: Any], - let toolCalls = message["tool_calls"] as? [[String: Any]] { - events.append(contentsOf: handleOllamaToolCalls(toolCalls, state: &state)) - } - - if let finishReason = firstChoice?["finish_reason"] as? String, !finishReason.isEmpty { - if let event = state.flushReasoningEnd() { - events.append(event) - } - if finishReason == "tool_calls" { - events.append(contentsOf: state.flushToolUseEnds()) - } - if finishReason == "length" { - events.append(.outputLimitReached(.outputTokens)) - } - } - // Ollama's own API names the cut in `done_reason`. - if (json["done"] as? Bool) == true, (json["done_reason"] as? String) == "length" { - events.append(.outputLimitReached(.outputTokens)) - } - - if let usage = json["usage"] as? [String: Any], - let promptTokens = usage["prompt_tokens"] as? Int, - let completionTokens = usage["completion_tokens"] as? Int { - state.inputTokens = promptTokens - state.outputTokens = completionTokens - } else if let done = json["done"] as? Bool, done, - let promptEval = json["prompt_eval_count"] as? Int, - let evalCount = json["eval_count"] as? Int { - state.inputTokens = promptEval - state.outputTokens = evalCount - } - - let shouldBreak = (json["done"] as? Bool) == true - if shouldBreak, !state.toolCallIndexToId.isEmpty { - events.append(contentsOf: state.flushToolUseEnds()) - } - let finished = (firstChoice?["finish_reason"] as? String)?.isEmpty == false - if !events.isEmpty || finished || shouldBreak { - state.receivedOutput = true - } - return (events, shouldBreak) - } - - private static func handleToolCallDeltas( - _ toolCalls: [[String: Any]], - state: inout OpenAIStreamState - ) -> [ChatStreamEvent] { - var events: [ChatStreamEvent] = [] - for toolCall in toolCalls { - guard let index = toolCall["index"] as? Int else { continue } - let function = toolCall["function"] as? [String: Any] - if state.toolCallIndexToId[index] == nil { - let id = (toolCall["id"] as? String) - ?? "call_\(index)_\(UUID().uuidString.prefix(8))" - let name = (function?["name"] as? String) ?? "" - state.toolCallIndexToId[index] = id - state.toolCallOrder.append(index) - events.append(.toolUseStart(id: id, name: name)) - } - if let id = state.toolCallIndexToId[index], - let arguments = function?["arguments"] as? String, - !arguments.isEmpty { - events.append(.toolUseDelta(id: id, inputJSONDelta: arguments)) - } - } - return events - } - - private static func handleOllamaToolCalls( - _ toolCalls: [[String: Any]], - state: inout OpenAIStreamState - ) -> [ChatStreamEvent] { - var events: [ChatStreamEvent] = [] - for (offset, toolCall) in toolCalls.enumerated() { - guard let function = toolCall["function"] as? [String: Any], - let name = function["name"] as? String else { continue } - let index = (toolCall["index"] as? Int) ?? offset - let id = (toolCall["id"] as? String) - ?? "call_\(index)_\(UUID().uuidString.prefix(8))" - if state.toolCallIndexToId[index] == nil { - state.toolCallIndexToId[index] = id - state.toolCallOrder.append(index) - events.append(.toolUseStart(id: id, name: name)) - } - let argumentsString: String - if let stringArgs = function["arguments"] as? String { - argumentsString = stringArgs - } else if let objectArgs = function["arguments"], - let data = try? JSONSerialization.data(withJSONObject: objectArgs), - let encoded = String(data: data, encoding: .utf8) { - argumentsString = encoded - } else { - argumentsString = "" - } - if !argumentsString.isEmpty, let resolvedId = state.toolCallIndexToId[index] { - events.append(.toolUseDelta(id: resolvedId, inputJSONDelta: argumentsString)) - } - } - return events } func fetchAvailableModels() async throws -> [AIModelInfo] { @@ -285,63 +101,33 @@ final class OpenAICompatibleProvider: ChatTransport { throw error } catch is URLError { throw AIProviderError.networkError( - String(format: String(localized: "Cannot connect to Ollama at %@. Is Ollama running?"), endpoint) + String(format: String(localized: "Cannot connect to Ollama at %@. Is Ollama running?"), transport.configuredEndpoint) ) } catch { throw AIProviderError.networkError( - String(format: String(localized: "Cannot connect to Ollama at %@. Is Ollama running?"), endpoint) + String(format: String(localized: "Cannot connect to Ollama at %@. Is Ollama running?"), transport.configuredEndpoint) ) } default: - let url = try requestURL(style.chatResource(model: testConnectionModel)) - - var request = URLRequest(url: url) - request.httpMethod = "POST" - request.setValue("application/json", forHTTPHeaderField: "Content-Type") - - if let apiKey, !apiKey.isEmpty { - request.setValue( - "Bearer \(apiKey)", - forHTTPHeaderField: "Authorization" - ) - } - - let body: [String: Any] = [ + let url = try transport.url(style.chatResource(model: testConnectionModel)) + let request = try transport.post(url, body: [ "model": testConnectionModel, "messages": [["role": "user", "content": "Hi"]], "max_tokens": 1, "stream": false, - ] - request.httpBody = try JSONSerialization.data(withJSONObject: body) - - let (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) - - guard let httpResponse = response as? HTTPURLResponse else { - return false - } - - let statusCode = httpResponse.statusCode + ]) + guard let reply = try await transport.connectionReply(to: request) else { return false } - if statusCode == 401 || (statusCode == 403 && treatsForbiddenAsAuthFailure) { - throw AIProviderError.authenticationFailed("") - } - - if statusCode == 200 || statusCode == 400 { - return Self.looksLikeAnAPIResponse(data: data, response: httpResponse) + if reply.statusCode == 200 || reply.statusCode == 400 { + return Self.looksLikeAnAPIResponse(reply) } // The placeholder model is unknown by design; that answer proves the route and the key. - if model.isEmpty, statusCode == 404, Self.isUnknownModelError(data) { + if model.isEmpty, reply.statusCode == 404, Self.isUnknownModelError(reply.data) { return true } - let errorBody = String(data: data, encoding: .utf8) ?? "" - throw AIProviderError.mapHTTPError( - statusCode: statusCode, - body: errorBody, - treatForbiddenAsAuthFailure: treatsForbiddenAsAuthFailure, - requestURL: url - ) + throw transport.httpError(reply, url: url) } } @@ -352,32 +138,20 @@ final class OpenAICompatibleProvider: ChatTransport { return error["code"] as? String == "model_not_found" } - /// A wrong Base URL often lands on a reverse proxy's login page or a single-page app's - /// fallback route, both of which answer 200 with HTML that the chat stream cannot read. - private static func looksLikeAnAPIResponse(data: Data, response: HTTPURLResponse) -> Bool { - let contentType = response.value(forHTTPHeaderField: "Content-Type")?.lowercased() ?? "" + // A wrong Base URL often lands on a login page or a single-page app's fallback route, both 200 with HTML. + private static func looksLikeAnAPIResponse(_ reply: AIHTTPReply) -> Bool { + let contentType = reply.response.value(forHTTPHeaderField: "Content-Type")?.lowercased() ?? "" if contentType.contains("application/json") || contentType.contains("text/event-stream") { return true } - return (try? JSONSerialization.jsonObject(with: data)) != nil + return (try? JSONSerialization.jsonObject(with: reply.data)) != nil } func buildChatCompletionRequest( turns: [ChatTurnWire], options: ChatTransportOptions ) throws -> URLRequest { - let url = try requestURL(style.chatResource(model: options.model)) - - var request = URLRequest(url: url) - request.httpMethod = "POST" - request.setValue("application/json", forHTTPHeaderField: "Content-Type") - - if let apiKey, !apiKey.isEmpty { - request.setValue( - "Bearer \(apiKey)", - forHTTPHeaderField: "Authorization" - ) - } + let url = try transport.url(style.chatResource(model: options.model)) var apiMessages: [[String: Any]] = [] if let systemPrompt = options.systemPrompt { @@ -395,8 +169,7 @@ final class OpenAICompatibleProvider: ChatTransport { let resolvedMaxTokens = options.maxOutputTokens ?? maxOutputTokens if let resolvedMaxTokens { - /// Ollama's native route reads the limit from `options` and ignores a top-level - /// `max_tokens`. + // Ollama's native route reads the limit from `options` and ignores a top-level `max_tokens`. if providerType == .ollama { body["options"] = ["num_predict": resolvedMaxTokens] } else { @@ -416,12 +189,10 @@ final class OpenAICompatibleProvider: ChatTransport { body["tools"] = try options.tools.map { try encodeTool($0) } } - request.httpBody = try JSONSerialization.data(withJSONObject: body) - return request + return try transport.post(url, body: body) } - /// The effort is withheld only from a model its own server lists as non-reasoning. A server - /// that says nothing about its models is taken at the user's word. + // Withheld only from a model its own server lists as non-reasoning; silence is taken at the user's word. private func acceptsReasoningEffort(model: String) -> Bool { guard providerType != .ollama else { return false } guard let reasoning = catalog.fetchedInfo(providerID: providerID, modelID: model)?.reasoning else { @@ -537,8 +308,7 @@ final class OpenAICompatibleProvider: ChatTransport { }.joined() } - /// Ollama's native route takes a string `content` with the images beside it as base64. It - /// rejects the content-part array the OpenAI wire format uses. + // Ollama's native route takes a string `content` with base64 images beside it, not a content-part array. private func ollamaImageMessage(text: String, images: [ChatImageInput]) -> [[String: Any]] { let payloads = images.compactMap { $0.base64Payload() } guard !text.isEmpty || !payloads.isEmpty else { return [] } @@ -573,132 +343,208 @@ final class OpenAICompatibleProvider: ChatTransport { } private func fetchOpenAIModels() async throws -> [AIModelInfo] { - let url = try requestURL(style.modelsResource) - - var request = URLRequest(url: url) - request.timeoutInterval = AIProvider.modelListTimeout - if let apiKey, !apiKey.isEmpty { - request.setValue( - "Bearer \(apiKey)", - forHTTPHeaderField: "Authorization" + let url = try transport.url(style.modelsResource) + let failed = { + AIProviderError.networkError( + String(format: String(localized: "Failed to fetch models from %@"), url.absoluteString) ) } - - let data: Data - let response: URLResponse - do { - (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) - } catch { + switch await transport.modelList(at: url, key: "data") { + case .unreachable(let error): Self.logger.warning("OpenAI-compatible model fetch failed: \(error.publicLogShape, privacy: .public)") - throw AIProviderError.networkError( - String(format: String(localized: "Failed to fetch models from %@"), url.absoluteString) - ) + throw failed() + case .notHTTP, .entries(nil): + throw failed() + case .rejected(let reply): + throw transport.httpError(reply, url: url) + case .entries(let modelsArray?): + return modelsArray.compactMap(Self.decodeModel(_:)) + .filter { modelIDs.lists($0.id) } + .sorted { $0.id < $1.id } } + } - guard let httpResponse = response as? HTTPURLResponse else { + private func fetchOllamaModels() async throws -> [String] { + let url = try transport.url(style.modelsResource) + let endpoint = transport.configuredEndpoint + switch await transport.modelList(at: url, key: "models", authenticated: false) { + case .unreachable(let error): + Self.logger.warning("Ollama model fetch failed: \(error.publicLogShape, privacy: .public)") throw AIProviderError.networkError( - String(format: String(localized: "Failed to fetch models from %@"), url.absoluteString) + String(format: String(localized: "Failed to fetch models from %@"), endpoint) ) - } - - guard httpResponse.statusCode == 200 else { - let body = String(data: data, encoding: .utf8) ?? "" - throw AIProviderError.mapHTTPError( - statusCode: httpResponse.statusCode, - body: body, - treatForbiddenAsAuthFailure: treatsForbiddenAsAuthFailure, - requestURL: url + case .notHTTP: + throw AIProviderError.networkError( + String(format: String(localized: "Failed to fetch models from %@ (HTTP %d)"), endpoint, 0) ) - } - - guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { + case .rejected(let reply): throw AIProviderError.networkError( - String(format: String(localized: "Failed to fetch models from %@"), url.absoluteString) + String(format: String(localized: "Failed to fetch models from %@ (HTTP %d)"), endpoint, reply.statusCode) ) - } - - guard let modelsArray = json["data"] as? [[String: Any]] else { + case .entries(nil): throw AIProviderError.networkError( String(format: String(localized: "Failed to fetch models from %@"), url.absoluteString) ) + case .entries(let models?): + return models.compactMap { $0["name"] as? String }.sorted() } + } +} + +struct ChatCompletionsStreamWire: ChatStreamWire { + // Ollama's native route streams one JSON object per line, not server-sent events. + let ollama: Bool - return modelsArray.compactMap(Self.decodeModel(_:)) - .filter { modelIDs.lists($0.id) } - .sorted { $0.id < $1.id } + func decodeLine(_ line: String) -> [String: Any]? { + guard ollama else { return SSEEventStream.jsonPayload(line) } + guard !line.isEmpty, + let data = line.data(using: .utf8), + let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] + else { return nil } + return json } - private func fetchOllamaModels() async throws -> [String] { - let url = try requestURL(style.modelsResource) - - var request = URLRequest(url: url) - request.timeoutInterval = AIProvider.modelListTimeout - let data: Data - let response: URLResponse - do { - (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) - } catch { - Self.logger.warning("Ollama model fetch failed: \(error.publicLogShape, privacy: .public)") - throw AIProviderError.networkError( - String(format: String(localized: "Failed to fetch models from %@"), endpoint) - ) + func parse(_ json: [String: Any], state: inout OpenAIStreamState) -> [ChatStreamEvent] { + var events: [ChatStreamEvent] = [] + let choices = json["choices"] as? [[String: Any]] + let firstChoice = choices?.first + let delta = firstChoice?["delta"] as? [String: Any] + + if let delta, let reasoningContent = delta["reasoning_content"] as? String, !reasoningContent.isEmpty { + let reasoningID: String + if let existing = state.reasoningBlockID { + reasoningID = existing + } else { + let newID = "reasoning_\(UUID().uuidString.prefix(8))" + state.reasoningBlockID = newID + events.append(.reasoningStart(id: newID)) + reasoningID = newID + } + events.append(.reasoningDelta(id: reasoningID, text: reasoningContent)) } - guard let httpResponse = response as? HTTPURLResponse, - httpResponse.statusCode == 200 - else { - let statusCode = (response as? HTTPURLResponse)?.statusCode ?? 0 - throw AIProviderError.networkError( - String(format: String(localized: "Failed to fetch models from %@ (HTTP %d)"), endpoint, statusCode) - ) + if let delta, let content = delta["content"] as? String, !content.isEmpty { + events.append(.textDelta(content)) + } else if let message = json["message"] as? [String: Any], + let content = message["content"] as? String, + !content.isEmpty { + events.append(.textDelta(content)) } - guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { - throw AIProviderError.networkError( - String(format: String(localized: "Failed to fetch models from %@"), url.absoluteString) - ) + if let delta, let toolCalls = delta["tool_calls"] as? [[String: Any]] { + events.append(contentsOf: Self.toolCallDeltas(toolCalls, state: &state)) + } else if let message = json["message"] as? [String: Any], + let toolCalls = message["tool_calls"] as? [[String: Any]] { + events.append(contentsOf: Self.ollamaToolCalls(toolCalls, state: &state)) } - guard let models = json["models"] as? [[String: Any]] else { - throw AIProviderError.networkError( - String(format: String(localized: "Failed to fetch models from %@"), url.absoluteString) - ) + if let finishReason = firstChoice?["finish_reason"] as? String, !finishReason.isEmpty { + if let event = state.flushReasoningEnd() { + events.append(event) + } + if finishReason == "tool_calls" { + events.append(contentsOf: state.toolCalls.endAll()) + } + if finishReason == "length" { + events.append(.outputLimitReached(.outputTokens)) + } + state.receivedOutput = true + } + // Ollama's own API names the cut in `done_reason`. + if (json["done"] as? Bool) == true, (json["done_reason"] as? String) == "length" { + events.append(.outputLimitReached(.outputTokens)) } - return models.compactMap { $0["name"] as? String }.sorted() + if let usage = json["usage"] as? [String: Any], + let promptTokens = usage["prompt_tokens"] as? Int, + let completionTokens = usage["completion_tokens"] as? Int { + state.inputTokens = promptTokens + state.outputTokens = completionTokens + } else if let done = json["done"] as? Bool, done, + let promptEval = json["prompt_eval_count"] as? Int, + let evalCount = json["eval_count"] as? Int { + state.inputTokens = promptEval + state.outputTokens = evalCount + } + + if (json["done"] as? Bool) == true { + events.append(contentsOf: state.toolCalls.endAll()) + state.receivedOutput = true + } + return events + } + + func closingEvents(_ state: inout OpenAIStreamState) -> [ChatStreamEvent] { + [state.flushReasoningEnd()].compactMap { $0 } + } + + private static func toolCallDeltas( + _ toolCalls: [[String: Any]], + state: inout OpenAIStreamState + ) -> [ChatStreamEvent] { + var events: [ChatStreamEvent] = [] + for toolCall in toolCalls { + guard let index = toolCall["index"] as? Int else { continue } + let function = toolCall["function"] as? [String: Any] + if state.toolCalls.id(for: index) == nil { + let id = (toolCall["id"] as? String) + ?? "call_\(index)_\(UUID().uuidString.prefix(8))" + let name = (function?["name"] as? String) ?? "" + if let start = state.toolCalls.start(index, id: id, name: name) { + events.append(start) + } + } + if let id = state.toolCalls.id(for: index), + let arguments = function?["arguments"] as? String, + !arguments.isEmpty { + events.append(.toolUseDelta(id: id, inputJSONDelta: arguments)) + } + } + return events + } + + private static func ollamaToolCalls( + _ toolCalls: [[String: Any]], + state: inout OpenAIStreamState + ) -> [ChatStreamEvent] { + var events: [ChatStreamEvent] = [] + for (offset, toolCall) in toolCalls.enumerated() { + guard let function = toolCall["function"] as? [String: Any], + let name = function["name"] as? String else { continue } + let index = (toolCall["index"] as? Int) ?? offset + let id = (toolCall["id"] as? String) + ?? "call_\(index)_\(UUID().uuidString.prefix(8))" + if let start = state.toolCalls.start(index, id: id, name: name) { + events.append(start) + } + let argumentsString: String + if let stringArgs = function["arguments"] as? String { + argumentsString = stringArgs + } else if let objectArgs = function["arguments"], + let data = try? JSONSerialization.data(withJSONObject: objectArgs), + let encoded = String(data: data, encoding: .utf8) { + argumentsString = encoded + } else { + argumentsString = "" + } + if !argumentsString.isEmpty, let resolvedId = state.toolCalls.id(for: index) { + events.append(.toolUseDelta(id: resolvedId, inputJSONDelta: argumentsString)) + } + } + return events } } -/// Mutable state carried across `OpenAICompatibleProvider.parseChunk` calls. -struct OpenAIStreamState { +struct OpenAIStreamState: ChatStreamState { var inputTokens: Int = 0 var outputTokens: Int = 0 - var toolCallIndexToId: [Int: String] = [:] - var toolCallOrder: [Int] = [] - var reasoningBlockID: String? var receivedOutput = false + var toolCalls = ToolCallTracker() + var reasoningBlockID: String? mutating func flushReasoningEnd() -> ChatStreamEvent? { guard let id = reasoningBlockID else { return nil } reasoningBlockID = nil return .reasoningEnd(id: id, opaque: nil) } - - /// Yield `.toolUseEnd` for every tracked tool call and clear the map. - /// Called when the provider signals tool-call completion (`finish_reason` - /// or Ollama `done: true`). - mutating func flushToolUseEnds() -> [ChatStreamEvent] { - let events: [ChatStreamEvent] = toolCallOrder.compactMap { index in - guard let id = toolCallIndexToId[index] else { return nil } - return .toolUseEnd(id: id) - } - toolCallIndexToId.removeAll() - toolCallOrder.removeAll() - return events - } - - func finalUsageEvent() -> ChatStreamEvent? { - guard inputTokens > 0 || outputTokens > 0 else { return nil } - return .usage(AITokenUsage(inputTokens: inputTokens, outputTokens: outputTokens)) - } } diff --git a/apple/TablePro/Core/AI/OpenAIResponsesProvider.swift b/apple/TablePro/Core/AI/OpenAIResponsesProvider.swift index 2ab633f0f4..55a9edfb98 100644 --- a/apple/TablePro/Core/AI/OpenAIResponsesProvider.swift +++ b/apple/TablePro/Core/AI/OpenAIResponsesProvider.swift @@ -5,7 +5,6 @@ import Foundation import os -import TableProHTTP import TableProMCP enum ResponsesDialect: Sendable { @@ -23,13 +22,10 @@ enum ResponsesDialect: Sendable { final class OpenAIResponsesProvider: ChatTransport { private static let logger = Logger(subsystem: "com.TablePro", category: "OpenAIResponsesProvider") - private let endpoint: String - private let resolvedEndpoint: AIEndpoint? - private let apiKey: String? + private let transport: AIProviderTransport private let model: String private let maxOutputTokens: Int? private let dialect: ResponsesDialect - private let session: URLSession init( endpoint: String, @@ -39,37 +35,31 @@ final class OpenAIResponsesProvider: ChatTransport { dialect: ResponsesDialect = .openAI, session: URLSession = URLSession(configuration: .ephemeral) ) { - self.endpoint = endpoint.trimmingCharacters(in: .whitespacesAndNewlines) - self.resolvedEndpoint = AIEndpoint(endpoint, style: .responses) - self.apiKey = apiKey?.trimmingCharacters(in: .whitespacesAndNewlines) + self.transport = AIProviderTransport( + endpoint: endpoint, + style: .responses, + headers: AIProviderTransport.bearer(apiKey?.trimmingCharacters(in: .whitespacesAndNewlines)), + session: session + ) self.model = model.trimmingCharacters(in: .whitespacesAndNewlines) self.maxOutputTokens = maxOutputTokens self.dialect = dialect - self.session = session - } - - private func requestURL(_ resource: String) throws -> URL { - guard let url = resolvedEndpoint?.url(appending: resource) else { - throw AIProviderError.invalidEndpoint(endpoint) - } - return url } func streamChat( turns: [ChatTurnWire], options: ChatTransportOptions ) -> AsyncThrowingStream { - ResponsesEventStream.make( - session: session, - buildRequest: { [self] in try buildRequest(turns: turns, options: options, stream: true) } - ) + transport.stream(ResponsesStreamWire()) { [self] in + try buildRequest(turns: turns, options: options, stream: true) + } } func fetchAvailableModels() async throws -> [AIModelInfo] { if dialect == .xai, let languageModels = await fetchXAILanguageModels() { return languageModels } - let host = resolvedEndpoint?.apiBase.host + let host = transport.endpoint?.apiBase.host return try await fetchModelEntries(resource: AIEndpointStyle.responses.modelsResource, key: "data") .filter { Self.listsChatModel($0, dialect: dialect, host: host) } .compactMap { $0["id"] as? String } @@ -127,28 +117,16 @@ final class OpenAIResponsesProvider: ChatTransport { } private func fetchModelEntries(resource: String, key: String) async throws -> [[String: Any]] { - let url = try requestURL(resource) - var request = URLRequest(url: url) - request.timeoutInterval = AIProvider.modelListTimeout - if let apiKey, !apiKey.isEmpty { - request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization") - } - let data: Data - let response: URLResponse - do { - (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) - } catch { + let url = try transport.url(resource) + switch await transport.modelList(at: url, key: key) { + case .unreachable(let error): Self.logger.warning("OpenAI Responses model fetch failed: \(error.publicLogShape, privacy: .public)") throw AIProviderError.networkError("Failed to fetch models") - } - guard let httpResponse = response as? HTTPURLResponse, - httpResponse.statusCode == 200, - let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any], - let entries = json[key] as? [[String: Any]] - else { + case .notHTTP, .rejected, .entries(nil): throw AIProviderError.networkError("Failed to fetch models") + case .entries(let entries?): + return entries } - return entries } func testConnection() async throws -> Bool { @@ -156,20 +134,11 @@ final class OpenAIResponsesProvider: ChatTransport { let testOptions = ChatTransportOptions(model: testModel, maxOutputTokens: 16) let testTurn = ChatTurnWire(role: .user, blocks: [.text("Hi")]) let request = try buildRequest(turns: [testTurn], options: testOptions, stream: false) - let (data, response) = try await session.data(for: request, delegate: SameOriginRedirects.shared) - guard let httpResponse = response as? HTTPURLResponse else { return false } - if httpResponse.statusCode == 200 || httpResponse.statusCode == 400 { - return true + guard let reply = try await transport.connectionReply(to: request) else { return false } + guard reply.statusCode == 200 || reply.statusCode == 400 else { + throw transport.httpError(reply, url: request.url) } - if httpResponse.statusCode == 401 { - throw AIProviderError.authenticationFailed("") - } - let body = String(data: data, encoding: .utf8) ?? "" - throw AIProviderError.mapHTTPError( - statusCode: httpResponse.statusCode, - body: body, - requestURL: request.url - ) + return true } private func buildRequest( @@ -177,13 +146,7 @@ final class OpenAIResponsesProvider: ChatTransport { options: ChatTransportOptions, stream: Bool ) throws -> URLRequest { - let url = try requestURL(AIEndpointStyle.responses.chatResource(model: options.model)) - var request = URLRequest(url: url) - request.httpMethod = "POST" - request.setValue("application/json", forHTTPHeaderField: "Content-Type") - if let apiKey, !apiKey.isEmpty { - request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization") - } + let url = try transport.url(AIEndpointStyle.responses.chatResource(model: options.model)) var body: [String: Any] = [ "model": options.model, @@ -217,8 +180,7 @@ final class OpenAIResponsesProvider: ChatTransport { body["tools"] = try options.tools.map(Self.encodeToolSpec(_:)) } - request.httpBody = try JSONSerialization.data(withJSONObject: body) - return request + return try transport.post(url, body: body) } static func encodeInput(turns: [ChatTurnWire]) throws -> [[String: Any]] { @@ -349,20 +311,10 @@ final class OpenAIResponsesProvider: ChatTransport { ]) parts = [] } +} - static func decodeStreamLine(_ line: String) -> [String: Any]? { - guard let payload = SSEEventStream.dataPayload(line), - payload != "[DONE]", - let data = payload.data(using: .utf8), - let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] - else { return nil } - return json - } - - static func parseEvent( - _ json: [String: Any], - state: inout ResponsesStreamState - ) throws -> [ChatStreamEvent] { +struct ResponsesStreamWire: ChatStreamWire { + func parse(_ json: [String: Any], state: inout ResponsesStreamState) throws -> [ChatStreamEvent] { guard let type = json["type"] as? String else { return [] } switch type { case "response.output_text.delta": @@ -385,8 +337,7 @@ final class OpenAIResponsesProvider: ChatTransport { case "function_call": guard let callID = item["call_id"] as? String, let name = item["name"] as? String else { return [] } - state.openFunctionCallIDs.insert(callID) - return [.toolUseStart(id: callID, name: name)] + return [state.toolCalls.start(callID, id: callID, name: name)].compactMap { $0 } default: return [] } @@ -409,12 +360,12 @@ final class OpenAIResponsesProvider: ChatTransport { return [.reasoningEnd(id: itemID, opaque: opaque)] case "function_call": guard let callID = item["call_id"] as? String, - state.openFunctionCallIDs.remove(callID) != nil else { return [] } + let end = state.toolCalls.end(callID) else { return [] } if !state.functionCallArgDeltaIDs.contains(callID), let arguments = item["arguments"] as? String, !arguments.isEmpty { - return [.toolUseDelta(id: callID, inputJSONDelta: arguments), .toolUseEnd(id: callID)] + return [.toolUseDelta(id: callID, inputJSONDelta: arguments), end] } - return [.toolUseEnd(id: callID)] + return [end] default: return [] } @@ -429,6 +380,7 @@ final class OpenAIResponsesProvider: ChatTransport { } return [] case "response.completed", "response.incomplete": + state.receivedOutput = true let responseObj = json["response"] as? [String: Any] if let usage = responseObj?["usage"] as? [String: Any] { let input = usage["input_tokens"] as? Int ?? 0 @@ -447,25 +399,19 @@ final class OpenAIResponsesProvider: ChatTransport { } throw AIProviderError.streamingFailed(String(localized: "Response failed")) case "error": - if let message = json["message"] as? String { - throw AIProviderError.streamingFailed(message) - } - return [] + let reason = json["message"] as? String ?? json["code"] as? String + throw AIProviderError.streamingFailed(reason ?? String(localized: "The provider reported an error.")) default: return [] } } } -struct ResponsesStreamState { +struct ResponsesStreamState: ChatStreamState { var inputTokens: Int = 0 var outputTokens: Int = 0 + var receivedOutput = false var openReasoningItemIDs: Set = [] - var openFunctionCallIDs: Set = [] + var toolCalls = ToolCallTracker() var functionCallArgDeltaIDs: Set = [] - - func finalUsageEvent() -> ChatStreamEvent? { - guard inputTokens > 0 || outputTokens > 0 else { return nil } - return .usage(AITokenUsage(inputTokens: inputTokens, outputTokens: outputTokens)) - } } diff --git a/apple/TablePro/Core/AI/ResponsesEventStream.swift b/apple/TablePro/Core/AI/ResponsesEventStream.swift deleted file mode 100644 index d368e42a87..0000000000 --- a/apple/TablePro/Core/AI/ResponsesEventStream.swift +++ /dev/null @@ -1,26 +0,0 @@ -// -// ResponsesEventStream.swift -// TablePro -// - -import Foundation - -enum ResponsesEventStream { - static func make( - session: URLSession, - treatForbiddenAsAuthFailure: Bool = false, - buildRequest: @escaping @Sendable () async throws -> URLRequest, - refreshOnUnauthorized: (@Sendable () async throws -> Void)? = nil - ) -> AsyncThrowingStream { - SSEEventStream.make( - session: session, - treatForbiddenAsAuthFailure: treatForbiddenAsAuthFailure, - buildRequest: buildRequest, - decodeLine: { OpenAIResponsesProvider.decodeStreamLine($0) }, - makeState: { ResponsesStreamState() }, - parse: { try OpenAIResponsesProvider.parseEvent($0, state: &$1) }, - finalEvents: { state in state.finalUsageEvent().map { [$0] } ?? [] }, - refreshOnUnauthorized: refreshOnUnauthorized - ) - } -} diff --git a/apple/TablePro/Core/AI/SSEEventStream.swift b/apple/TablePro/Core/AI/SSEEventStream.swift index 40ddde4444..90cf0e1499 100644 --- a/apple/TablePro/Core/AI/SSEEventStream.swift +++ b/apple/TablePro/Core/AI/SSEEventStream.swift @@ -14,14 +14,20 @@ enum SSEEventStream { return String(value.first == " " ? value.dropFirst() : value) } - static func make( + static func jsonPayload(_ line: String) -> [String: Any]? { + guard let payload = dataPayload(line), + payload != "[DONE]", + let data = payload.data(using: .utf8), + let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] + else { return nil } + return json + } + + static func make( session: URLSession, treatForbiddenAsAuthFailure: Bool = false, + wire: Wire, buildRequest: @escaping @Sendable () async throws -> URLRequest, - decodeLine: @escaping @Sendable (String) -> [String: Any]?, - makeState: @escaping @Sendable () -> State, - parse: @escaping @Sendable ([String: Any], inout State) throws -> [ChatStreamEvent], - finalEvents: @escaping @Sendable (State) throws -> [ChatStreamEvent] = { _ in [] }, refreshOnUnauthorized: (@Sendable () async throws -> Void)? = nil ) -> AsyncThrowingStream { AsyncThrowingStream { continuation in @@ -48,14 +54,15 @@ enum SSEEventStream { ) } - var state = makeState() + var state = Wire.State() for try await line in bytes.lines { if Task.isCancelled { break } - guard let json = decodeLine(line) else { continue } - let events = try parse(json, &state) - for event in events { continuation.yield(event) } + guard let json = wire.decodeLine(line) else { continue } + for event in try wire.events(from: json, state: &state) { + continuation.yield(event) + } } - for final in try finalEvents(state) { + for final in try wire.finalEvents(state) { continuation.yield(final) } continuation.finish() diff --git a/apple/TableProTests/Core/AI/AIProviderTransportTests.swift b/apple/TableProTests/Core/AI/AIProviderTransportTests.swift new file mode 100644 index 0000000000..79eec4f9e9 --- /dev/null +++ b/apple/TableProTests/Core/AI/AIProviderTransportTests.swift @@ -0,0 +1,88 @@ +// +// AIProviderTransportTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import Testing + +struct AIProviderTransportTests { + private func transport(headers: [String: String]) -> AIProviderTransport { + AIProviderTransport( + endpoint: " https://host.example ", + style: .chatCompletions, + headers: headers, + session: URLSession(configuration: .ephemeral) + ) + } + + @Test("A bearer header goes out only for a key that is not empty") + func bearerNeedsAKey() { + #expect(AIProviderTransport.bearer("sk-1") == ["Authorization": "Bearer sk-1"]) + #expect(AIProviderTransport.bearer("").isEmpty) + #expect(AIProviderTransport.bearer(nil).isEmpty) + } + + @Test("A POST carries JSON, the configured headers and the body") + func postShape() throws { + let transport = transport(headers: ["Authorization": "Bearer k", "anthropic-version": "2023-06-01"]) + let request = try transport.post(try transport.url("chat/completions"), body: ["model": "m"]) + #expect(request.httpMethod == "POST") + #expect(request.url?.absoluteString == "https://host.example/v1/chat/completions") + #expect(request.value(forHTTPHeaderField: "Content-Type") == "application/json") + #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer k") + #expect(request.value(forHTTPHeaderField: "anthropic-version") == "2023-06-01") + let body = try JSONSerialization.jsonObject(with: try #require(request.httpBody)) as? [String: Any] + #expect(body?["model"] as? String == "m") + } + + @Test("A model-list GET carries the headers and the short timeout; an unauthenticated one carries none") + func getShape() throws { + let transport = transport(headers: ["Authorization": "Bearer k"]) + let url = try transport.url("models") + let request = transport.get(url) + #expect(request.httpMethod == "GET") + #expect(request.timeoutInterval == AIProvider.modelListTimeout) + #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer k") + #expect(transport.get(url, authenticated: false).value(forHTTPHeaderField: "Authorization") == nil) + #expect(transport.get(url, timeout: nil).timeoutInterval == URLRequest(url: url).timeoutInterval) + } + + @Test("An endpoint that does not resolve reports what the user typed, trimmed") + func invalidEndpoint() { + let transport = AIProviderTransport( + endpoint: " api.example.com/v1 ", + style: .chatCompletions, + headers: [:], + session: URLSession(configuration: .ephemeral) + ) + let error = #expect(throws: AIProviderError.self) { _ = try transport.url("models") } + guard case .invalidEndpoint(let endpoint)? = error else { + Issue.record("expected invalidEndpoint; got \(String(describing: error))") + return + } + #expect(endpoint == "api.example.com/v1") + } + + @Test("Claude sends its key header and API version; OpenAI-compatible sends a bearer only with a key") + func providerHeaders() throws { + let turn = ChatTurnWire(role: .user, blocks: [.text("Hi")]) + let options = ChatTransportOptions(model: "m") + + let claude = try AnthropicProvider(endpoint: "https://api.anthropic.com", apiKey: " sk-ant ") + .buildMessagesRequest(turns: [turn], options: options, effort: nil) + #expect(claude.value(forHTTPHeaderField: "x-api-key") == "sk-ant") + #expect(claude.value(forHTTPHeaderField: "anthropic-version") == "2023-06-01") + #expect(claude.value(forHTTPHeaderField: "Authorization") == nil) + + let keyed = try OpenAICompatibleProvider(endpoint: "https://host/v1", apiKey: " sk-1 ", providerType: .custom) + .buildChatCompletionRequest(turns: [turn], options: options) + #expect(keyed.value(forHTTPHeaderField: "Authorization") == "Bearer sk-1") + #expect(keyed.value(forHTTPHeaderField: "Content-Type") == "application/json") + + let keyless = try OpenAICompatibleProvider(endpoint: "http://localhost:11434", apiKey: nil, providerType: .ollama) + .buildChatCompletionRequest(turns: [turn], options: options) + #expect(keyless.value(forHTTPHeaderField: "Authorization") == nil) + } +} diff --git a/apple/TableProTests/Core/AI/AnthropicProviderParserTests.swift b/apple/TableProTests/Core/AI/AnthropicProviderParserTests.swift index 99c04e04ac..161e726e26 100644 --- a/apple/TableProTests/Core/AI/AnthropicProviderParserTests.swift +++ b/apple/TableProTests/Core/AI/AnthropicProviderParserTests.swift @@ -10,7 +10,7 @@ import Testing struct AnthropicProviderParserTests { private func parse(_ json: [String: Any], state: inout AnthropicStreamState) throws -> [ChatStreamEvent] { - try AnthropicProvider.parseChunk(json, state: &state) + try AnthropicStreamWire().events(from: json, state: &state) } @Test("text_delta yields textDelta") @@ -46,13 +46,13 @@ struct AnthropicProviderParserTests { } else { Issue.record("expected toolUseStart; got \(events)") } - #expect(state.toolUseIdsByIndex[1] == "toolu_abc") + #expect(state.toolCalls.id(for: 1) == "toolu_abc") } @Test("input_json_delta resolves index back to id from state") func inputJSONDelta() throws { var state = AnthropicStreamState() - state.toolUseIdsByIndex[1] = "toolu_abc" + _ = state.toolCalls.start(1, id: "toolu_abc", name: "list_tables") let events = try parse([ "type": "content_block_delta", "index": 1, @@ -80,7 +80,7 @@ struct AnthropicProviderParserTests { @Test("content_block_stop yields toolUseEnd and clears the index mapping") func toolUseEnd() throws { var state = AnthropicStreamState() - state.toolUseIdsByIndex[1] = "toolu_abc" + _ = state.toolCalls.start(1, id: "toolu_abc", name: "list_tables") let events = try parse([ "type": "content_block_stop", "index": 1 @@ -90,7 +90,7 @@ struct AnthropicProviderParserTests { } else { Issue.record("expected toolUseEnd; got \(events)") } - #expect(state.toolUseIdsByIndex[1] == nil) + #expect(state.toolCalls.id(for: 1) == nil) } @Test("Fragmented input_json_delta concatenates correctly via state") @@ -167,37 +167,37 @@ struct AnthropicProviderParserTests { func errorEvent() { var state = AnthropicStreamState() #expect(throws: AIProviderError.self) { - _ = try AnthropicProvider.parseChunk( - ["type": "error", "error": ["message": "rate limited"]], + _ = try AnthropicStreamWire().events( + from: ["type": "error", "error": ["message": "rate limited"]], state: &state ) } } - @Test("decodeStreamLine returns nil for non-data lines and [DONE]") + @Test("The line decoder returns nil for non-data lines and [DONE]") func framingDecode() { - #expect(AnthropicProvider.decodeStreamLine("event: message_stop") == nil) - #expect(AnthropicProvider.decodeStreamLine("data: [DONE]") == nil) - #expect(AnthropicProvider.decodeStreamLine("data: {\"type\":\"x\"}") != nil) + #expect(AnthropicStreamWire().decodeLine("event: message_stop") == nil) + #expect(AnthropicStreamWire().decodeLine("data: [DONE]") == nil) + #expect(AnthropicStreamWire().decodeLine("data: {\"type\":\"x\"}") != nil) } @Test("Unknown event types yield no events and don't throw") func unknownEventType() throws { var state = AnthropicStreamState() - let events = try AnthropicProvider.parseChunk( - ["type": "ping", "extra": "ignored"], + let events = try AnthropicStreamWire().events( + from: ["type": "ping", "extra": "ignored"], state: &state ) #expect(events.isEmpty) // State should be unchanged. - #expect(state.toolUseIdsByIndex.isEmpty) + #expect(state.toolCalls.isEmpty) #expect(state.inputTokens == 0) } @Test("Chunk with no type field yields no events and doesn't throw") func chunkWithoutType() throws { var state = AnthropicStreamState() - let events = try AnthropicProvider.parseChunk(["random": "data"], state: &state) + let events = try AnthropicStreamWire().events(from: ["random": "data"], state: &state) #expect(events.isEmpty) } } diff --git a/apple/TableProTests/Core/AI/GeminiProviderParserTests.swift b/apple/TableProTests/Core/AI/GeminiProviderParserTests.swift index 743fe34b82..906af497ee 100644 --- a/apple/TableProTests/Core/AI/GeminiProviderParserTests.swift +++ b/apple/TableProTests/Core/AI/GeminiProviderParserTests.swift @@ -4,6 +4,7 @@ // import Foundation +import os import TableProPluginKit @testable import TablePro import Testing @@ -12,7 +13,7 @@ struct GeminiProviderParserTests { private let stableID = "stable-id" private func parse(_ json: [String: Any], state: inout GeminiStreamState) -> [ChatStreamEvent] { - GeminiProvider.parseChunk(json, state: &state, idGenerator: { self.stableID }) + GeminiStreamWire(idGenerator: { stableID }).parse(json, state: &state) } @Test("Text part yields textDelta") @@ -140,8 +141,14 @@ struct GeminiProviderParserTests { @Test("Multiple functionCall parts in one chunk get distinct ids") func multipleFunctionCallsGetDistinctIds() { var state = GeminiStreamState() - var counter = 0 - let events = GeminiProvider.parseChunk([ + let counter = OSAllocatedUnfairLock(initialState: 0) + let wire = GeminiStreamWire(idGenerator: { + counter.withLock { count in + defer { count += 1 } + return "id-\(count)" + } + }) + let events = wire.parse([ "candidates": [[ "content": [ "parts": [ @@ -150,10 +157,7 @@ struct GeminiProviderParserTests { ] ] ]] - ], state: &state, idGenerator: { - defer { counter += 1 } - return "id-\(counter)" - }) + ], state: &state) let starts = events.compactMap { event -> String? in if case .toolUseStart(let id, _, _) = event { return id } return nil diff --git a/apple/TableProTests/Core/AI/OpenAICompatibleProviderParserTests.swift b/apple/TableProTests/Core/AI/OpenAICompatibleProviderParserTests.swift index f036ece50c..b0e7095b29 100644 --- a/apple/TableProTests/Core/AI/OpenAICompatibleProviderParserTests.swift +++ b/apple/TableProTests/Core/AI/OpenAICompatibleProviderParserTests.swift @@ -9,17 +9,18 @@ import TableProPluginKit import Testing struct OpenAICompatibleProviderParserTests { + private let wire = ChatCompletionsStreamWire(ollama: false) + @Test("delta.content yields textDelta") func textDelta() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "choices": [[ "delta": ["content": "hello"] ]] ], state: &state) - #expect(result.shouldBreak == false) - guard case .textDelta(let text) = result.events.first else { - Issue.record("expected textDelta; got \(result.events)") + guard case .textDelta(let text) = events.first else { + Issue.record("expected textDelta; got \(events)") return } #expect(text == "hello") @@ -28,7 +29,7 @@ struct OpenAICompatibleProviderParserTests { @Test("First tool_calls chunk emits toolUseStart with id and name") func toolUseStart() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "choices": [[ "delta": [ "tool_calls": [[ @@ -40,22 +41,21 @@ struct OpenAICompatibleProviderParserTests { ] ]] ], state: &state) - #expect(result.events.count == 1) - if case .toolUseStart(let id, let name, _) = result.events.first { + #expect(events.count == 1) + if case .toolUseStart(let id, let name, _) = events.first { #expect(id == "call_abc") #expect(name == "list_tables") } else { - Issue.record("expected toolUseStart; got \(result.events)") + Issue.record("expected toolUseStart; got \(events)") } - #expect(state.toolCallIndexToId[0] == "call_abc") + #expect(state.toolCalls.id(for: 0) == "call_abc") } @Test("Subsequent tool_calls chunks emit toolUseDelta only") func toolUseDelta() { var state = OpenAIStreamState() - state.toolCallIndexToId[0] = "call_abc" - state.toolCallOrder = [0] - let result = OpenAICompatibleProvider.parseChunk([ + _ = state.toolCalls.start(0, id: "call_abc", name: "list_tables") + let events = wire.parse([ "choices": [[ "delta": [ "tool_calls": [[ @@ -65,36 +65,35 @@ struct OpenAICompatibleProviderParserTests { ] ]] ], state: &state) - #expect(result.events.count == 1) - if case .toolUseDelta(let id, let delta) = result.events.first { + #expect(events.count == 1) + if case .toolUseDelta(let id, let delta) = events.first { #expect(id == "call_abc") #expect(delta == #"{"foo":"#) } else { - Issue.record("expected toolUseDelta; got \(result.events)") + Issue.record("expected toolUseDelta; got \(events)") } } @Test("finish_reason: tool_calls flushes toolUseEnds for all tracked calls") func finishReasonTriggersFlush() { var state = OpenAIStreamState() - state.toolCallIndexToId = [0: "call_a", 1: "call_b"] - state.toolCallOrder = [0, 1] - let result = OpenAICompatibleProvider.parseChunk([ + _ = state.toolCalls.start(0, id: "call_a", name: "list_tables") + _ = state.toolCalls.start(1, id: "call_b", name: "describe_table") + let events = wire.parse([ "choices": [["finish_reason": "tool_calls"]] ], state: &state) - let endIds = result.events.compactMap { event -> String? in + let endIds = events.compactMap { event -> String? in if case .toolUseEnd(let id) = event { return id } return nil } #expect(endIds == ["call_a", "call_b"]) - #expect(state.toolCallIndexToId.isEmpty) - #expect(state.toolCallOrder.isEmpty) + #expect(state.toolCalls.isEmpty) } @Test("Ollama message.tool_calls with arguments-as-object encodes to JSON string") func ollamaArgumentsAsObject() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "message": [ "tool_calls": [[ "function": [ @@ -104,7 +103,7 @@ struct OpenAICompatibleProviderParserTests { ]] ] ], state: &state) - let deltaPayload = result.events.compactMap { event -> String? in + let deltaPayload = events.compactMap { event -> String? in if case .toolUseDelta(_, let s) = event { return s } return nil }.first @@ -115,7 +114,7 @@ struct OpenAICompatibleProviderParserTests { @Test("Ollama message.tool_calls with arguments-as-string passes through verbatim") func ollamaArgumentsAsString() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "message": [ "tool_calls": [[ "function": [ @@ -125,25 +124,24 @@ struct OpenAICompatibleProviderParserTests { ]] ] ], state: &state) - let delta = result.events.compactMap { event -> String? in + let delta = events.compactMap { event -> String? in if case .toolUseDelta(_, let s) = event { return s } return nil }.first #expect(delta == #"{"connection_id":"abc"}"#) } - @Test("Ollama done: true sets shouldBreak and flushes pending tool ends") + @Test("Ollama done: true ends the response and flushes pending tool ends") func ollamaDoneFlushesAndBreaks() { var state = OpenAIStreamState() - state.toolCallIndexToId[0] = "call_a" - state.toolCallOrder = [0] - let result = OpenAICompatibleProvider.parseChunk([ + _ = state.toolCalls.start(0, id: "call_a", name: "list_tables") + let events = wire.parse([ "done": true, "prompt_eval_count": 50, "eval_count": 200 ], state: &state) - #expect(result.shouldBreak == true) - #expect(result.events.contains(where: { event in + #expect(state.receivedOutput) + #expect(events.contains(where: { event in if case .toolUseEnd(let id) = event { return id == "call_a" } return false })) @@ -154,7 +152,7 @@ struct OpenAICompatibleProviderParserTests { @Test("usage object populates state token counters") func usageTokens() { var state = OpenAIStreamState() - _ = OpenAICompatibleProvider.parseChunk([ + _ = wire.parse([ "usage": ["prompt_tokens": 30, "completion_tokens": 90] ], state: &state) #expect(state.inputTokens == 30) @@ -164,11 +162,11 @@ struct OpenAICompatibleProviderParserTests { @Test("message.content path yields textDelta (Ollama non-stream + final-message OpenAI)") func messageContentPathYieldsTextDelta() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "message": ["content": "hi"] ], state: &state) - guard case .textDelta(let text) = result.events.first else { - Issue.record("expected textDelta from message.content; got \(result.events)") + guard case .textDelta(let text) = events.first else { + Issue.record("expected textDelta from message.content; got \(events)") return } #expect(text == "hi") @@ -177,18 +175,18 @@ struct OpenAICompatibleProviderParserTests { @Test("delta.reasoning_content on first chunk emits reasoningStart then reasoningDelta") func reasoningContentFirstChunk() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "choices": [[ "delta": ["reasoning_content": "Let me think..."] ]] ], state: &state) - #expect(result.events.count == 2) - guard case .reasoningStart(let id) = result.events[0] else { - Issue.record("expected reasoningStart; got \(result.events[0])") + #expect(events.count == 2) + guard case .reasoningStart(let id) = events[0] else { + Issue.record("expected reasoningStart; got \(events[0])") return } - guard case .reasoningDelta(let deltaID, let text) = result.events[1] else { - Issue.record("expected reasoningDelta; got \(result.events[1])") + guard case .reasoningDelta(let deltaID, let text) = events[1] else { + Issue.record("expected reasoningDelta; got \(events[1])") return } #expect(deltaID == id) @@ -200,14 +198,14 @@ struct OpenAICompatibleProviderParserTests { func reasoningContentSubsequentChunk() { var state = OpenAIStreamState() state.reasoningBlockID = "reasoning_abc" - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "choices": [[ "delta": ["reasoning_content": " more thinking"] ]] ], state: &state) - #expect(result.events.count == 1) - guard case .reasoningDelta(let id, let text) = result.events[0] else { - Issue.record("expected reasoningDelta; got \(result.events)") + #expect(events.count == 1) + guard case .reasoningDelta(let id, let text) = events[0] else { + Issue.record("expected reasoningDelta; got \(events)") return } #expect(id == "reasoning_abc") @@ -218,12 +216,12 @@ struct OpenAICompatibleProviderParserTests { func finishReasonStopClosesReasoningBlock() { var state = OpenAIStreamState() state.reasoningBlockID = "reasoning_xyz" - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "choices": [["finish_reason": "stop"]] ], state: &state) - #expect(result.events.count == 1) - guard case .reasoningEnd(let id, let opaque) = result.events[0] else { - Issue.record("expected reasoningEnd; got \(result.events)") + #expect(events.count == 1) + guard case .reasoningEnd(let id, let opaque) = events[0] else { + Issue.record("expected reasoningEnd; got \(events)") return } #expect(id == "reasoning_xyz") @@ -234,13 +232,13 @@ struct OpenAICompatibleProviderParserTests { @Test("reasoning_content followed by finish_reason in same chunk emits start, delta, end") func reasoningContentWithFinishReason() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "choices": [[ "delta": ["reasoning_content": "final thought"], "finish_reason": "stop" ]] ], state: &state) - let kinds = result.events.map { event -> String in + let kinds = events.map { event -> String in switch event { case .reasoningStart: return "start" case .reasoningDelta: return "delta" @@ -255,15 +253,15 @@ struct OpenAICompatibleProviderParserTests { @Test("delta.reasoning_content: null is ignored and does not emit reasoningStart") func reasoningContentNullIgnored() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = wire.parse([ "choices": [[ "delta": ["content": "hello", "reasoning_content": NSNull()] ]] ], state: &state) #expect(state.reasoningBlockID == nil) - #expect(result.events.count == 1) - guard case .textDelta = result.events[0] else { - Issue.record("expected only textDelta; got \(result.events)") + #expect(events.count == 1) + guard case .textDelta = events[0] else { + Issue.record("expected only textDelta; got \(events)") return } } @@ -271,46 +269,40 @@ struct OpenAICompatibleProviderParserTests { @Test("finish_reason: stop does not flush pending tool calls") func finishReasonStopLeavesToolCallsIntact() { var state = OpenAIStreamState() - state.toolCallIndexToId = [0: "call_a"] - state.toolCallOrder = [0] - let result = OpenAICompatibleProvider.parseChunk([ + _ = state.toolCalls.start(0, id: "call_a", name: "list_tables") + let events = wire.parse([ "choices": [["finish_reason": "stop"]] ], state: &state) - #expect(result.events.isEmpty) - #expect(state.toolCallIndexToId[0] == "call_a") + #expect(events.isEmpty) + #expect(state.toolCalls.id(for: 0) == "call_a") } - @Test("Empty chunk yields no events and doesn't break") + @Test("Empty chunk yields no events and doesn't end the response") func emptyChunk() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([:], state: &state) - #expect(result.events.isEmpty) - #expect(result.shouldBreak == false) + let events = wire.parse([:], state: &state) + #expect(events.isEmpty) + #expect(!state.receivedOutput) } - @Test("done: true with no pending tool calls breaks without emitting") + @Test("done: true with no pending tool calls ends the response without emitting") func doneWithNoPendingTools() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk(["done": true], state: &state) - #expect(result.shouldBreak == true) - #expect(result.events.isEmpty) + let events = wire.parse(["done": true], state: &state) + #expect(state.receivedOutput) + #expect(events.isEmpty) } - @Test("decodeStreamLine respects providerType (SSE vs NDJSON)") + @Test("The line decoder follows the framing (SSE vs NDJSON)") func decodeStreamLineFraming() { - let openAIParsed = OpenAICompatibleProvider.decodeStreamLine( - #"data: {"choices":[]}"#, - providerType: .openAI - ) + let openAIParsed = wire.decodeLine(#"data: {"choices":[]}"#) #expect(openAIParsed != nil) - let openAIDone = OpenAICompatibleProvider.decodeStreamLine("data: [DONE]", providerType: .openAI) + let openAIDone = wire.decodeLine("data: [DONE]") #expect(openAIDone == nil) - let ollamaParsed = OpenAICompatibleProvider.decodeStreamLine( - #"{"done":true}"#, - providerType: .ollama - ) + let ollama = ChatCompletionsStreamWire(ollama: true) + let ollamaParsed = ollama.decodeLine(#"{"done":true}"#) #expect(ollamaParsed != nil) - let ollamaEmpty = OpenAICompatibleProvider.decodeStreamLine("", providerType: .ollama) + let ollamaEmpty = ollama.decodeLine("") #expect(ollamaEmpty == nil) } @@ -328,10 +320,10 @@ struct OpenAICompatibleProviderParserTests { var state = OpenAIStreamState() var events: [ChatStreamEvent] = [] for line in lines { - guard let json = OpenAICompatibleProvider.decodeStreamLine(line, providerType: .custom) else { continue } - events += try OpenAICompatibleProvider.streamEvents(from: json, state: &state) + guard let json = wire.decodeLine(line) else { continue } + events += try wire.events(from: json, state: &state) } - events += try OpenAICompatibleProvider.finalStreamEvents(state) + events += try wire.finalEvents(state) guard events.count == 5 else { Issue.record("expected 5 events; got \(events)") diff --git a/apple/TableProTests/Core/AI/OpenAIResponsesProviderParserTests.swift b/apple/TableProTests/Core/AI/OpenAIResponsesProviderParserTests.swift index c1b17836bc..5640762d51 100644 --- a/apple/TableProTests/Core/AI/OpenAIResponsesProviderParserTests.swift +++ b/apple/TableProTests/Core/AI/OpenAIResponsesProviderParserTests.swift @@ -9,7 +9,7 @@ import Testing struct OpenAIResponsesProviderParserTests { private func parse(_ json: [String: Any], state: inout ResponsesStreamState) throws -> [ChatStreamEvent] { - try OpenAIResponsesProvider.parseEvent(json, state: &state) + try ResponsesStreamWire().events(from: json, state: &state) } @Test("output_text.delta yields textDelta") @@ -216,20 +216,20 @@ struct OpenAIResponsesProviderParserTests { func responseFailedThrows() throws { var state = ResponsesStreamState() #expect(throws: AIProviderError.self) { - _ = try OpenAIResponsesProvider.parseEvent([ + _ = try ResponsesStreamWire().events(from: [ "type": "response.failed", "response": ["error": ["message": "rate limit exceeded"]] ], state: &state) } } - @Test("decodeStreamLine handles data prefix and DONE sentinel") + @Test("The line decoder handles the data prefix and the DONE sentinel") func decodeStreamLineFraming() { - let json = OpenAIResponsesProvider.decodeStreamLine( + let json = ResponsesStreamWire().decodeLine( #"data: {"type":"response.created","response":{"id":"r1"}}"# ) #expect(json?["type"] as? String == "response.created") - #expect(OpenAIResponsesProvider.decodeStreamLine("data: [DONE]") == nil) - #expect(OpenAIResponsesProvider.decodeStreamLine(": comment line") == nil) + #expect(ResponsesStreamWire().decodeLine("data: [DONE]") == nil) + #expect(ResponsesStreamWire().decodeLine(": comment line") == nil) } } diff --git a/apple/TableProTests/Core/AI/OutputLimitSignalTests.swift b/apple/TableProTests/Core/AI/OutputLimitSignalTests.swift index cf91ae70ea..706906d2ec 100644 --- a/apple/TableProTests/Core/AI/OutputLimitSignalTests.swift +++ b/apple/TableProTests/Core/AI/OutputLimitSignalTests.swift @@ -24,7 +24,7 @@ struct OutputLimitSignalTests { ] as [(String, [ChatOutputLimit])]) func anthropicStopReason(reason: String, expected: [ChatOutputLimit]) throws { var state = AnthropicStreamState() - let events = try AnthropicProvider.parseChunk([ + let events = try AnthropicStreamWire().events(from: [ "type": "message_delta", "delta": ["stop_reason": reason], "usage": ["output_tokens": 12], @@ -40,27 +40,27 @@ struct OutputLimitSignalTests { ] as [(String, [ChatOutputLimit])]) func chatCompletionsFinishReason(reason: String, expected: [ChatOutputLimit]) { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = ChatCompletionsStreamWire(ollama: false).parse([ "choices": [["delta": [:] as [String: Any], "finish_reason": reason]], ], state: &state) - #expect(limits(result.events) == expected) + #expect(limits(events) == expected) } @Test("Ollama's done_reason length is reported") func ollamaDoneReason() { var state = OpenAIStreamState() - let result = OpenAICompatibleProvider.parseChunk([ + let events = ChatCompletionsStreamWire(ollama: true).parse([ "message": ["content": ""], "done": true, "done_reason": "length", ], state: &state) - #expect(limits(result.events) == [.outputTokens]) + #expect(limits(events) == [.outputTokens]) } @Test("A Responses stream that ends incomplete at max_output_tokens is reported, with its usage") func responsesIncomplete() throws { var state = ResponsesStreamState() - let events = try OpenAIResponsesProvider.parseEvent([ + let events = try ResponsesStreamWire().events(from: [ "type": "response.incomplete", "response": [ "status": "incomplete", @@ -76,7 +76,7 @@ struct OutputLimitSignalTests { @Test("A Responses stream cut by its content filter is not an output limit") func responsesContentFilter() throws { var state = ResponsesStreamState() - let events = try OpenAIResponsesProvider.parseEvent([ + let events = try ResponsesStreamWire().events(from: [ "type": "response.incomplete", "response": ["incomplete_details": ["reason": "content_filter"]], ], state: &state) @@ -89,9 +89,9 @@ struct OutputLimitSignalTests { ] as [(String, [ChatOutputLimit])]) func geminiFinishReason(reason: String, expected: [ChatOutputLimit]) { var state = GeminiStreamState() - let events = GeminiProvider.parseChunk([ + let events = GeminiStreamWire(idGenerator: { "id" }).parse([ "candidates": [["content": ["parts": [["text": "partial"]]], "finishReason": reason]], - ], state: &state, idGenerator: { "id" }) + ], state: &state) #expect(limits(events) == expected) } diff --git a/apple/TableProTests/Core/AI/ProviderStreamFailureTests.swift b/apple/TableProTests/Core/AI/ProviderStreamFailureTests.swift index 22379e0339..85819cb92d 100644 --- a/apple/TableProTests/Core/AI/ProviderStreamFailureTests.swift +++ b/apple/TableProTests/Core/AI/ProviderStreamFailureTests.swift @@ -26,20 +26,20 @@ struct ProviderStreamFailureTests { @Test("Every SSE provider decodes a data line that has no space") func providersDecodeLineWithoutSpace() { let line = #"data:{"choices":[]}"# - #expect(OpenAICompatibleProvider.decodeStreamLine(line, providerType: .openAI) != nil) - #expect(OpenAICompatibleProvider.decodeStreamLine("data:[DONE]", providerType: .openAI) == nil) - #expect(AnthropicProvider.decodeStreamLine(#"data:{"type":"ping"}"#) != nil) - #expect(AnthropicProvider.decodeStreamLine("data:[DONE]") == nil) - #expect(OpenAIResponsesProvider.decodeStreamLine(#"data:{"type":"response.created"}"#) != nil) - #expect(OpenAIResponsesProvider.decodeStreamLine("data:[DONE]") == nil) - #expect(GeminiProvider.decodeStreamLine(#"data:{"candidates":[]}"#) != nil) + #expect(ChatCompletionsStreamWire(ollama: false).decodeLine(line) != nil) + #expect(ChatCompletionsStreamWire(ollama: false).decodeLine("data:[DONE]") == nil) + #expect(AnthropicStreamWire().decodeLine(#"data:{"type":"ping"}"#) != nil) + #expect(AnthropicStreamWire().decodeLine("data:[DONE]") == nil) + #expect(ResponsesStreamWire().decodeLine(#"data:{"type":"response.created"}"#) != nil) + #expect(ResponsesStreamWire().decodeLine("data:[DONE]") == nil) + #expect(GeminiStreamWire().decodeLine(#"data:{"candidates":[]}"#) != nil) } @Test("An error chunk in a chat completions stream fails the stream with its message") func errorChunkThrows() { var state = OpenAIStreamState() let error = #expect(throws: AIProviderError.self) { - _ = try OpenAICompatibleProvider.streamEvents( + _ = try ChatCompletionsStreamWire(ollama: false).events( from: ["error": ["message": "Rate limit reached", "code": 429]], state: &state ) @@ -64,7 +64,7 @@ struct ProviderStreamFailureTests { #expect(AIProviderError.streamError(in: ["choices": [[String: Any]]()]) == nil) #expect(AIProviderError.streamError(in: ["error": NSNull()]) == nil) var state = OpenAIStreamState() - let events = try OpenAICompatibleProvider.streamEvents( + let events = try ChatCompletionsStreamWire(ollama: false).events( from: ["error": NSNull(), "choices": [["delta": ["content": "hi"]]]], state: &state ) @@ -74,7 +74,7 @@ struct ProviderStreamFailureTests { @Test("A stream that ends having sent nothing is a failure") func emptyStreamThrows() { let error = #expect(throws: AIProviderError.self) { - _ = try OpenAICompatibleProvider.finalStreamEvents(OpenAIStreamState()) + _ = try ChatCompletionsStreamWire(ollama: false).finalEvents(OpenAIStreamState()) } #expect(streamingFailureMessage(error) != nil) } @@ -82,27 +82,167 @@ struct ProviderStreamFailureTests { @Test("A stream that sent text ends normally") func textStreamEnds() throws { var state = OpenAIStreamState() - _ = try OpenAICompatibleProvider.streamEvents( + _ = try ChatCompletionsStreamWire(ollama: false).events( from: ["choices": [["delta": ["content": "hi"]]]], state: &state ) - _ = try OpenAICompatibleProvider.finalStreamEvents(state) + _ = try ChatCompletionsStreamWire(ollama: false).finalEvents(state) } @Test("A stream with only a finish reason ends normally") func finishReasonOnlyEnds() throws { var state = OpenAIStreamState() - _ = try OpenAICompatibleProvider.streamEvents( + _ = try ChatCompletionsStreamWire(ollama: false).events( from: ["choices": [["delta": [String: Any](), "finish_reason": "stop"]]], state: &state ) - _ = try OpenAICompatibleProvider.finalStreamEvents(state) + _ = try ChatCompletionsStreamWire(ollama: false).finalEvents(state) } @Test("An Ollama stream that only reports done ends normally") func ollamaDoneEnds() throws { var state = OpenAIStreamState() - _ = try OpenAICompatibleProvider.streamEvents(from: ["done": true], state: &state) - _ = try OpenAICompatibleProvider.finalStreamEvents(state) + _ = try ChatCompletionsStreamWire(ollama: false).events(from: ["done": true], state: &state) + _ = try ChatCompletionsStreamWire(ollama: false).finalEvents(state) + } + + @Test("Claude, Responses and Gemini streams that end having sent nothing are failures too") + func emptyStreamThrowsOnEveryWire() { + let claude = #expect(throws: AIProviderError.self) { + _ = try AnthropicStreamWire().finalEvents(AnthropicStreamState()) + } + let responses = #expect(throws: AIProviderError.self) { + _ = try ResponsesStreamWire().finalEvents(ResponsesStreamState()) + } + let gemini = #expect(throws: AIProviderError.self) { + _ = try GeminiStreamWire().finalEvents(GeminiStreamState()) + } + #expect(streamingFailureMessage(claude) != nil) + #expect(streamingFailureMessage(responses) != nil) + #expect(streamingFailureMessage(gemini) != nil) + } + + @Test("A stream that only says the reply is over ends normally on every wire") + func endFrameAloneEnds() throws { + var claude = AnthropicStreamState() + _ = try AnthropicStreamWire().events(from: ["type": "message_stop"], state: &claude) + _ = try AnthropicStreamWire().finalEvents(claude) + + var claudeDelta = AnthropicStreamState() + _ = try AnthropicStreamWire().events( + from: ["type": "message_delta", "delta": ["stop_reason": "end_turn"]], + state: &claudeDelta + ) + _ = try AnthropicStreamWire().finalEvents(claudeDelta) + + var responses = ResponsesStreamState() + _ = try ResponsesStreamWire().events( + from: ["type": "response.completed", "response": ["status": "completed"]], + state: &responses + ) + _ = try ResponsesStreamWire().finalEvents(responses) + + var gemini = GeminiStreamState() + _ = try GeminiStreamWire().events(from: ["candidates": [["finishReason": "STOP"]]], state: &gemini) + _ = try GeminiStreamWire().finalEvents(gemini) + } + + @Test("A Gemini prompt blocked with no candidates ends normally and keeps its usage") + func geminiBlockedPromptEnds() throws { + var state = GeminiStreamState() + let events = try GeminiStreamWire().events( + from: ["promptFeedback": ["blockReason": "SAFETY"], "usageMetadata": ["promptTokenCount": 12]], + state: &state + ) + #expect(events.isEmpty) + let final = try GeminiStreamWire().finalEvents(state) + guard final.count == 1, case .usage(let usage) = final[0] else { + Issue.record("expected usage only; got \(final)") + return + } + #expect(usage.inputTokens == 12) + } + + @Test("A Claude stream whose only frames carry no content and no end is a failure") + func claudeStartOnlyThrows() throws { + var state = AnthropicStreamState() + _ = try AnthropicStreamWire().events( + from: ["type": "message_start", "message": ["usage": ["input_tokens": 12]]], + state: &state + ) + #expect(throws: AIProviderError.self) { _ = try AnthropicStreamWire().finalEvents(state) } + } + + @Test("A Claude error event with no message still fails the stream, with its type") + func claudeErrorWithoutMessage() { + var state = AnthropicStreamState() + let error = #expect(throws: AIProviderError.self) { + _ = try AnthropicStreamWire().events( + from: ["type": "error", "error": ["type": "overloaded_error"]], + state: &state + ) + } + #expect(streamingFailureMessage(error) == "overloaded_error") + } + + @Test("A Responses error event fails the stream with its message, or its code without one") + func responsesErrorEvent() { + var state = ResponsesStreamState() + let withMessage = #expect(throws: AIProviderError.self) { + _ = try ResponsesStreamWire().events( + from: ["type": "error", "code": "server_error", "message": "Try again"], + state: &state + ) + } + #expect(streamingFailureMessage(withMessage) == "Try again") + let withCode = #expect(throws: AIProviderError.self) { + _ = try ResponsesStreamWire().events(from: ["type": "error", "code": "server_error"], state: &state) + } + #expect(streamingFailureMessage(withCode) == "server_error") + } + + @Test("The final usage follows the closing events") + func usageComesLast() throws { + var state = OpenAIStreamState() + _ = try ChatCompletionsStreamWire(ollama: false).events( + from: [ + "choices": [["delta": ["reasoning_content": "hm"]]], + "usage": ["prompt_tokens": 3, "completion_tokens": 4], + ], + state: &state + ) + let final = try ChatCompletionsStreamWire(ollama: false).finalEvents(state) + guard final.count == 2, case .reasoningEnd = final[0], case .usage(let usage) = final[1] else { + Issue.record("expected reasoningEnd then usage; got \(final)") + return + } + #expect(usage.inputTokens == 3) + #expect(usage.outputTokens == 4) + } +} + +struct ToolCallTrackerTests { + @Test("A second start for an open call opens nothing, and the call keeps its first id") + func repeatedStartIsIgnored() { + var tracker = ToolCallTracker() + #expect(tracker.start(0, id: "call_a", name: "list_tables") != nil) + #expect(tracker.start(0, id: "call_b", name: "list_tables") == nil) + #expect(tracker.id(for: 0) == "call_a") + } + + @Test("Ending all calls closes them in the order they started") + func endAllKeepsStartOrder() { + var tracker = ToolCallTracker() + _ = tracker.start(3, id: "c", name: "x") + _ = tracker.start(1, id: "a", name: "x") + _ = tracker.start(2, id: "b", name: "x") + _ = tracker.end(1) + let ends = tracker.endAll().compactMap { event -> String? in + if case .toolUseEnd(let id) = event { return id } + return nil + } + #expect(ends == ["c", "b"]) + #expect(tracker.isEmpty) + #expect(tracker.end(3) == nil) } } diff --git a/apple/TableProTests/Core/AI/SSEEventStreamTests.swift b/apple/TableProTests/Core/AI/SSEEventStreamTests.swift index 0f70d1efbf..60b04d47a8 100644 --- a/apple/TableProTests/Core/AI/SSEEventStreamTests.swift +++ b/apple/TableProTests/Core/AI/SSEEventStreamTests.swift @@ -7,8 +7,23 @@ import Foundation @testable import TablePro import Testing -private struct SSETestState { - var deltas = 0 +private struct SSETestState: ChatStreamState { + var inputTokens = 0 + var outputTokens = 0 + var receivedOutput = false +} + +private struct SSETestWire: ChatStreamWire { + var closing: [String] = [] + + func parse(_ json: [String: Any], state: inout SSETestState) -> [ChatStreamEvent] { + guard let text = json["text"] as? String else { return [] } + return [.textDelta(text)] + } + + func closingEvents(_ state: inout SSETestState) -> [ChatStreamEvent] { + closing.map { .textDelta($0) } + } } private actor RefreshCounter { @@ -20,22 +35,6 @@ private func sseRequest() -> URLRequest { URLRequest(url: URL(string: "https://example.com/responses")!) } -private func sseDecodeLine(_ line: String) -> [String: Any]? { - guard line.hasPrefix("data: ") else { return nil } - let payload = String(line.dropFirst(6)) - guard let data = payload.data(using: .utf8), - let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { - return nil - } - return json -} - -private func sseParse(_ json: [String: Any], _ state: inout SSETestState) -> [ChatStreamEvent] { - guard let text = json["text"] as? String else { return [] } - state.deltas += 1 - return [.textDelta(text)] -} - private func collectText(_ stream: AsyncThrowingStream) async throws -> [String] { var texts: [String] = [] for try await event in stream { @@ -99,11 +98,8 @@ struct SSEEventStreamTests { ) let stream = SSEEventStream.make( session: session, - buildRequest: { sseRequest() }, - decodeLine: sseDecodeLine, - makeState: { SSETestState() }, - parse: { sseParse($0, &$1) }, - finalEvents: { _ in [.textDelta("FINAL")] } + wire: SSETestWire(closing: ["FINAL"]), + buildRequest: { sseRequest() } ) let texts = try await collectText(stream) #expect(texts == ["a", "b", "FINAL"]) @@ -114,10 +110,8 @@ struct SSEEventStreamTests { let session = MockSSEProtocol.session(replying: [(500, Data("{\"error\":{\"message\":\"boom\"}}".utf8))]) let stream = SSEEventStream.make( session: session, - buildRequest: { sseRequest() }, - decodeLine: sseDecodeLine, - makeState: { SSETestState() }, - parse: { sseParse($0, &$1) } + wire: SSETestWire(), + buildRequest: { sseRequest() } ) await #expect(throws: AIProviderError.self) { _ = try await collectText(stream) @@ -133,14 +127,40 @@ struct SSEEventStreamTests { let counter = RefreshCounter() let stream = SSEEventStream.make( session: session, + wire: SSETestWire(), buildRequest: { sseRequest() }, - decodeLine: sseDecodeLine, - makeState: { SSETestState() }, - parse: { sseParse($0, &$1) }, refreshOnUnauthorized: { await counter.bump() } ) let texts = try await collectText(stream) #expect(texts == ["ok"]) #expect(await counter.count == 1) } + + @Test("A 200 whose body holds no event fails instead of ending as an empty reply") + func pageInsteadOfStreamThrows() async throws { + let session = MockSSEProtocol.session(replying: [(200, Data("Sign in".utf8))]) + let stream = SSEEventStream.make( + session: session, + wire: SSETestWire(), + buildRequest: { sseRequest() } + ) + await #expect(throws: AIProviderError.self) { + _ = try await collectText(stream) + } + } + + @Test("An error frame fails the stream on any wire") + func errorFrameThrows() async throws { + let session = MockSSEProtocol.session( + replying: [(200, Data("data: {\"text\":\"a\"}\n\ndata: {\"error\":{\"message\":\"boom\"}}\n\n".utf8))] + ) + let stream = SSEEventStream.make( + session: session, + wire: SSETestWire(), + buildRequest: { sseRequest() } + ) + await #expect(throws: AIProviderError.self) { + _ = try await collectText(stream) + } + } } diff --git a/core/crates/core/src/call_options.rs b/core/crates/core/src/call_options.rs index e6c83f345b..150aa8f8fe 100644 --- a/core/crates/core/src/call_options.rs +++ b/core/crates/core/src/call_options.rs @@ -26,3 +26,34 @@ impl CallOptions { &self.cancel } } + +/// Resolves when `deadline` passes, and never when there is none. +pub async fn deadline_elapsed(deadline: Option) { + match deadline { + Some(at) => tokio::time::sleep_until(at).await, + None => std::future::pending().await, + } +} + +#[cfg(test)] +mod tests { + use std::time::Duration; + + use super::*; + + #[tokio::test(start_paused = true)] + async fn a_passed_deadline_resolves_and_no_deadline_never_does() { + let past = Instant::now(); + tokio::time::advance(Duration::from_secs(1)).await; + assert!( + tokio::time::timeout(Duration::from_secs(1), deadline_elapsed(Some(past))) + .await + .is_ok() + ); + assert!( + tokio::time::timeout(Duration::from_secs(3600), deadline_elapsed(None)) + .await + .is_err() + ); + } +} diff --git a/core/crates/drivers/clickhouse/src/session_status.rs b/core/crates/core/src/editor_session_status.rs similarity index 73% rename from core/crates/drivers/clickhouse/src/session_status.rs rename to core/crates/core/src/editor_session_status.rs index 7c2aa7b82c..fba5101e92 100644 --- a/core/crates/drivers/clickhouse/src/session_status.rs +++ b/core/crates/core/src/editor_session_status.rs @@ -1,6 +1,8 @@ use std::sync::atomic::{AtomicU8, Ordering}; -use tablepro_core::{DriverError, EditorSessionState, LossPhase}; +use crate::editor_session::EditorSessionState; +use crate::error::DriverError; +use crate::loss_phase::LossPhase; const READY: u8 = 0; const RUNNING: u8 = 1; @@ -8,18 +10,18 @@ const LOST: u8 = 2; /// What an editor session handle answers without waiting for a run. #[derive(Debug)] -pub(crate) struct SessionStatus { +pub struct EditorSessionStatus { state: AtomicU8, } -impl SessionStatus { - pub(crate) fn new() -> Self { +impl EditorSessionStatus { + pub fn new() -> Self { Self { state: AtomicU8::new(READY), } } - pub(crate) fn state(&self) -> EditorSessionState { + pub fn state(&self) -> EditorSessionState { match self.state.load(Ordering::SeqCst) { READY => EditorSessionState::Ready, RUNNING => EditorSessionState::Running, @@ -27,9 +29,8 @@ impl SessionStatus { } } - /// Claim the session for one run: the server refuses a second query - /// on a session that is still running one. - pub(crate) fn begin(&self) -> Result<(), DriverError> { + /// Claim the session for one run: a session runs one at a time. + pub fn begin(&self) -> Result<(), DriverError> { match self .state .compare_exchange(READY, RUNNING, Ordering::SeqCst, Ordering::SeqCst) @@ -42,24 +43,31 @@ impl SessionStatus { } } - pub(crate) fn finish(&self) { + // A session lost while it ran stays lost. + pub fn finish(&self) { let _ = self .state .compare_exchange(RUNNING, READY, Ordering::SeqCst, Ordering::SeqCst); } - pub(crate) fn lose(&self) { + pub fn lose(&self) { self.state.store(LOST, Ordering::SeqCst); } } +impl Default for EditorSessionStatus { + fn default() -> Self { + Self::new() + } +} + #[cfg(test)] mod tests { use super::*; #[test] fn a_second_run_is_busy_and_a_lost_session_refuses_runs() { - let status = SessionStatus::new(); + let status = EditorSessionStatus::new(); assert!(status.begin().is_ok()); assert_eq!(status.begin(), Err(DriverError::EditorSessionBusy)); diff --git a/core/crates/core/src/lib.rs b/core/crates/core/src/lib.rs index 73874815da..5a175656c4 100644 --- a/core/crates/core/src/lib.rs +++ b/core/crates/core/src/lib.rs @@ -28,6 +28,7 @@ mod driver; pub mod dump; pub mod edit; mod editor_session; +mod editor_session_status; mod engine_category; mod engine_stop; mod error; @@ -58,6 +59,7 @@ mod network_target; mod owned_calls; pub mod query_result; mod query_timeout; +mod read_emitter; mod read_only_refusal; mod read_statement; mod registry; @@ -110,7 +112,7 @@ pub use auth_mode::AuthMode; pub use busy_reason::BusyReason; pub use byte_limit::ByteLimit; pub use byte_limited_sink::ByteLimitSink; -pub use call_options::CallOptions; +pub use call_options::{CallOptions, deadline_elapsed}; pub use capabilities::{ CommitResolutionSupport, DataModel, DriverCapabilities, EndpointKind, EstimateQuality, ReadOnlyEnforcement, ScriptExecution, StatementStop, @@ -129,6 +131,7 @@ pub use copy_in::{CopyInPiece, CopyInRows, CopyInSummary}; pub use credentials::Credentials; pub use driver::DatabaseDriver; pub use editor_session::{EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState}; +pub use editor_session_status::EditorSessionStatus; pub use engine_category::EngineCategory; pub use engine_stop::{CallResource, EngineStop, StopDelivery, StopScope}; pub use error::DriverError; @@ -160,6 +163,7 @@ pub use network_target::NetworkTarget; pub use owned_calls::OwnedCalls; pub use query_result::QueryResult; pub use query_timeout::QueryTimeout; +pub use read_emitter::ReadEmitter; pub use read_only_refusal::ReadOnlyRefusal; pub use read_statement::ReadStatement; pub use registry::DriverRegistry; diff --git a/core/crates/core/src/owned_calls.rs b/core/crates/core/src/owned_calls.rs index 0332fafd97..a234e71af1 100644 --- a/core/crates/core/src/owned_calls.rs +++ b/core/crates/core/src/owned_calls.rs @@ -7,7 +7,7 @@ use tokio::time::Instant; use tokio_util::sync::CancellationToken; use tokio_util::task::TaskTracker; -use crate::call_options::CallOptions; +use crate::call_options::{CallOptions, deadline_elapsed}; use crate::engine_stop::{CallResource, EngineStop, StopDelivery, StopScope}; use crate::error::DriverError; use crate::loss_phase::LossPhase; @@ -340,13 +340,6 @@ fn reason_error(reason: StopReason) -> DriverError { } } -async fn deadline_elapsed(deadline: Option) { - match deadline { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } -} - #[cfg(test)] mod tests { use std::sync::atomic::AtomicUsize; diff --git a/core/crates/core/src/read_emitter.rs b/core/crates/core/src/read_emitter.rs new file mode 100644 index 0000000000..49a14fc8ef --- /dev/null +++ b/core/crates/core/src/read_emitter.rs @@ -0,0 +1,190 @@ +use std::sync::Arc; + +use crate::column::ResultColumn; +use crate::error::DriverError; +use crate::result_event::{ResultEvent, Truncation}; +use crate::result_sink::{ResultSink, SinkFlow}; +use crate::row_batch::RowBatch; +use crate::value::Value; + +/// A whole read's rows into a sink, for an export, in batches of +/// `RowBatch::MAX_ROWS` rows. Each batch is awaited, so a slow consumer +/// slows the read instead of growing a queue. +pub struct ReadEmitter<'a> { + sink: &'a mut dyn ResultSink, + batch: Vec>, + open: bool, + set_rows: u64, + rows: u64, +} + +impl<'a> ReadEmitter<'a> { + pub fn new(sink: &'a mut dyn ResultSink) -> Self { + Self { + sink, + batch: Vec::new(), + open: false, + set_rows: 0, + rows: 0, + } + } + + /// Every row so far, across result sets. + pub fn rows(&self) -> u64 { + self.rows + } + + pub fn is_open(&self) -> bool { + self.open + } + + pub async fn start(&mut self, columns: Arc<[ResultColumn]>) -> Result<(), DriverError> { + self.open = true; + self.send(ResultEvent::ResultSetStarted { columns }).await + } + + pub async fn row(&mut self, values: Vec) -> Result<(), DriverError> { + self.batch.push(values); + self.rows += 1; + self.set_rows += 1; + if self.batch.len() >= RowBatch::MAX_ROWS { + self.flush().await?; + } + Ok(()) + } + + pub async fn flush(&mut self) -> Result<(), DriverError> { + if self.batch.is_empty() { + return Ok(()); + } + let rows = std::mem::take(&mut self.batch); + self.send(ResultEvent::Rows(rows)).await + } + + // Sent whether or not a set is open: a statement that ends with no rows still ends its set. + pub async fn finish(&mut self) -> Result<(), DriverError> { + self.flush().await?; + self.open = false; + let rows = std::mem::take(&mut self.set_rows); + self.send(ResultEvent::ResultSetFinished { + retained: rows, + total_rows: Some(rows), + truncation: Truncation::Complete, + }) + .await + } + + /// A consumer that went away ends the read: the rows would go + /// nowhere. + pub async fn send(&mut self, event: ResultEvent) -> Result<(), DriverError> { + match self.sink.accept(event).await { + SinkFlow::Continue => Ok(()), + SinkFlow::ConsumerGone => Err(DriverError::Cancelled), + } + } +} + +#[cfg(test)] +mod tests { + use async_trait::async_trait; + + use super::*; + use crate::column::ColumnType; + + #[derive(Default)] + struct Recorded { + events: Vec, + gone: bool, + } + + #[async_trait] + impl ResultSink for Recorded { + async fn accept(&mut self, event: ResultEvent) -> SinkFlow { + self.events.push(event); + match self.gone { + true => SinkFlow::ConsumerGone, + false => SinkFlow::Continue, + } + } + } + + fn columns() -> Arc<[ResultColumn]> { + vec![ResultColumn::new("n", ColumnType::untyped_text(""))].into() + } + + fn finished(rows: u64) -> ResultEvent { + ResultEvent::ResultSetFinished { + retained: rows, + total_rows: Some(rows), + truncation: Truncation::Complete, + } + } + + fn batch_sizes(events: &[ResultEvent]) -> Vec { + events + .iter() + .filter_map(|event| match event { + ResultEvent::Rows(rows) => Some(rows.len()), + _ => None, + }) + .collect() + } + + #[tokio::test] + async fn rows_go_out_in_batches_of_256() { + let mut sink = Recorded::default(); + let mut emitter = ReadEmitter::new(&mut sink); + emitter.start(columns()).await.expect("started"); + for n in 0..257 { + emitter.row(vec![Value::Int(n)]).await.expect("a row"); + } + emitter.finish().await.expect("finished"); + + assert_eq!(batch_sizes(&sink.events), vec![256, 1]); + assert_eq!(sink.events.last(), Some(&finished(257))); + } + + #[tokio::test] + async fn finish_counts_its_own_set_and_rows_counts_them_all() { + let mut sink = Recorded::default(); + let mut emitter = ReadEmitter::new(&mut sink); + emitter.start(columns()).await.expect("started"); + for n in 0..3 { + emitter.row(vec![Value::Int(n)]).await.expect("a row"); + } + emitter.finish().await.expect("finished"); + assert!(!emitter.is_open()); + emitter.start(columns()).await.expect("started"); + assert!(emitter.is_open()); + emitter.row(vec![Value::Int(3)]).await.expect("a row"); + emitter.finish().await.expect("finished"); + assert_eq!(emitter.rows(), 4); + + let ends: Vec<&ResultEvent> = sink + .events + .iter() + .filter(|event| matches!(event, ResultEvent::ResultSetFinished { .. })) + .collect(); + assert_eq!(ends, vec![&finished(3), &finished(1)]); + } + + #[tokio::test] + async fn finish_with_no_set_open_still_ends_one() { + let mut sink = Recorded::default(); + let mut emitter = ReadEmitter::new(&mut sink); + emitter.finish().await.expect("finished"); + + assert_eq!(sink.events, vec![finished(0)]); + } + + #[tokio::test] + async fn a_consumer_that_went_away_cancels_the_read() { + let mut sink = Recorded { + gone: true, + ..Recorded::default() + }; + let mut emitter = ReadEmitter::new(&mut sink); + + assert_eq!(emitter.start(columns()).await, Err(DriverError::Cancelled)); + } +} diff --git a/core/crates/core/src/write_batch.rs b/core/crates/core/src/write_batch.rs index 30dff881e4..1c01fba0c8 100644 --- a/core/crates/core/src/write_batch.rs +++ b/core/crates/core/src/write_batch.rs @@ -1,5 +1,7 @@ +use crate::error::DriverError; use crate::foreign_key_mode::ForeignKeyMode; use crate::meta::TableRef; +use crate::read_only_refusal::ReadOnlyRefusal; use crate::statement::GuardedStatement; /// What a write is changing, which decides how it is wrapped. @@ -46,4 +48,43 @@ impl WriteBatch { pub fn len(&self) -> usize { self.steps.len() } + + /// Refuse a batch before anything is sent: a read-only connection + /// never writes, and only SQLite can suspend foreign keys. + pub fn precheck(&self, read_only: bool) -> Result<(), DriverError> { + if read_only { + return Err(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)); + } + self.foreign_keys.require_enforced() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::unsupported_feature::UnsupportedFeature; + + fn batch(foreign_keys: ForeignKeyMode) -> WriteBatch { + WriteBatch::new( + WriteKind::RowChanges, + TableRef::new(None, "t"), + Vec::new(), + foreign_keys, + ) + } + + #[test] + fn a_read_only_connection_and_suspended_foreign_keys_are_refused() { + assert_eq!(batch(ForeignKeyMode::Enforced).precheck(false), Ok(())); + assert_eq!( + batch(ForeignKeyMode::Enforced).precheck(true), + Err(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)) + ); + assert_eq!( + batch(ForeignKeyMode::SuspendedThenVerified { checks: Vec::new() }).precheck(false), + Err(DriverError::Unsupported { + feature: UnsupportedFeature::ForeignKeySuspension, + }) + ); + } } diff --git a/core/crates/drivers/cassandra/src/editor.rs b/core/crates/drivers/cassandra/src/editor.rs index b3cc4a8251..4a548a4a78 100644 --- a/core/crates/drivers/cassandra/src/editor.rs +++ b/core/crates/drivers/cassandra/src/editor.rs @@ -4,7 +4,6 @@ //! only that tab, as cqlsh moves only its own connection. CQL keeps no //! other state on a connection: no transaction, no temporary table. -use std::sync::atomic::{AtomicU8, Ordering}; use std::sync::{Arc, Mutex, PoisonError}; use std::time::Duration; @@ -14,9 +13,9 @@ use scylla::statement::unprepared::Statement as CqlStatement; use tablepro_core::sql_syntax::script::{LexicalSettings, ScriptPlan}; use tablepro_core::sql_syntax::{SqlGrammar, StatementAccess, statement_access}; use tablepro_core::{ - CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionState, ErrorCategory, LossPhase, - ReadOnlyRefusal, ResultEvent, ResultSink, RowLimit, RunEnd, RunOptions, RunSummary, ServerNotice, SinkFlow, - TransactionState, Truncation, UserSql, + CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionState, EditorSessionStatus, ErrorCategory, + LossPhase, ReadOnlyRefusal, ResultEvent, ResultSink, RowBatch, RowLimit, RunEnd, RunOptions, RunSummary, + ServerNotice, SinkFlow, TransactionState, Truncation, UserSql, deadline_elapsed, }; use tokio::time::Instant; use tokio_util::sync::CancellationToken; @@ -26,20 +25,12 @@ use crate::result_origin::SpecTable; use crate::rows::{ColumnsRead, MAX_PAGE_ROWS, next_state, page_size}; use crate::session::{CqlLink, LinkSlot}; -/// Rows per `ResultEvent::Rows`. The sink is awaited per batch, so a slow -/// grid slows the read instead of growing a queue. -const BATCH_ROWS: usize = 256; - -const READY: u8 = 0; -const RUNNING: u8 = 1; -const LOST: u8 = 2; - pub(crate) struct CqlEditorSession { id: EditorSessionId, link: LinkSlot, read_only: bool, statement_timeout: Option, - state: Arc, + status: Arc, shutdown: CancellationToken, /// The keyspace the server confirmed. The driver records one it is /// still moving to, or failed to. @@ -55,23 +46,10 @@ impl CqlEditorSession { link: LinkSlot::new(link), read_only, statement_timeout, - state: Arc::new(AtomicU8::new(READY)), + status: Arc::new(EditorSessionStatus::new()), shutdown: CancellationToken::new(), } } - - fn begin(&self) -> Result<(), DriverError> { - match self - .state - .compare_exchange(READY, RUNNING, Ordering::SeqCst, Ordering::SeqCst) - { - Ok(_) => Ok(()), - Err(RUNNING) => Err(DriverError::EditorSessionBusy), - Err(_) => Err(DriverError::ConnectionLost { - during: LossPhase::Idle, - }), - } - } } #[async_trait] @@ -90,12 +68,12 @@ impl EditorSession for CqlEditorSession { /// session ends. async fn use_database(&self, database: &str, options: CallOptions) -> Result<(), DriverError> { let link = self.link.get()?; - self.begin()?; + self.status.begin()?; let using = link.session().use_keyspace(database, true); let used = tokio::select! { biased; () = options.cancel().cancelled() => Err(DriverError::Cancelled), - () = until(options.deadline()) => Err(DriverError::Timeout { + () = deadline_elapsed(options.deadline()) => Err(DriverError::Timeout { phase: tablepro_core::TimeoutPhase::Statement, server_cancelled: false, }), @@ -104,11 +82,11 @@ impl EditorSession for CqlEditorSession { match used { Ok(()) => { *self.keyspace.lock().unwrap_or_else(PoisonError::into_inner) = Some(database.to_owned()); - self.state.store(READY, Ordering::SeqCst); + self.status.finish(); Ok(()) } Err(error) => { - self.state.store(LOST, Ordering::SeqCst); + self.status.lose(); self.link.release(); Err(error) } @@ -116,11 +94,7 @@ impl EditorSession for CqlEditorSession { } fn state(&self) -> EditorSessionState { - match self.state.load(Ordering::SeqCst) { - READY => EditorSessionState::Ready, - RUNNING => EditorSessionState::Running, - _ => EditorSessionState::Lost, - } + self.status.state() } /// The run goes on a task of its own, so a dropped caller is a @@ -132,7 +106,7 @@ impl EditorSession for CqlEditorSession { sink: Box, ) -> Result { let link = self.link.get()?; - self.begin()?; + self.status.begin()?; let guard = options.cancel.clone().drop_guard(); let run = Run { link, @@ -140,7 +114,7 @@ impl EditorSession for CqlEditorSession { statement_timeout: self.statement_timeout, shutdown: self.shutdown.clone(), }; - let state = self.state.clone(); + let status = self.status.clone(); let (keyspace, link) = (self.keyspace.clone(), run.link.clone()); let follows = tablepro_core::sql_syntax::may_change_database(sql.as_str(), SqlGrammar::Cql); let running = tokio::spawn(async move { @@ -150,15 +124,14 @@ impl EditorSession for CqlEditorSession { *keyspace.lock().unwrap_or_else(PoisonError::into_inner) = link.session().get_keyspace().map(|keyspace| keyspace.to_string()); } - let next = match &outcome { - Ok(_) => READY, - Err(_) => LOST, - }; - let _ = state.compare_exchange(RUNNING, next, Ordering::SeqCst, Ordering::SeqCst); + match &outcome { + Ok(_) => status.finish(), + Err(_) => status.lose(), + } outcome }); let outcome = running.await.unwrap_or_else(|_| { - self.state.store(LOST, Ordering::SeqCst); + self.status.lose(); Err(DriverError::ConnectionLost { during: LossPhase::Statement, }) @@ -180,7 +153,7 @@ impl EditorSession for CqlEditorSession { /// server runs to its own timeout. async fn close(&self) { self.shutdown.cancel(); - self.state.store(LOST, Ordering::SeqCst); + self.status.lose(); self.link.release(); } } @@ -336,7 +309,7 @@ impl Run { let past_limit = decoded.len() > room; let kept: Vec<_> = decoded.into_iter().take(room).collect(); retained += kept.len() as u64; - for batch in kept.chunks(BATCH_ROWS) { + for batch in kept.chunks(RowBatch::MAX_ROWS) { emitter.send(ResultEvent::Rows(batch.to_vec())).await; } if past_limit { @@ -385,16 +358,10 @@ struct Stop<'a> { impl Stop<'_> { async fn triggered(&self) -> Interrupt { - let deadline = async { - match self.deadline { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } - }; tokio::select! { () = self.cancel.cancelled() => Interrupt::Cancelled, () = self.shutdown.cancelled() => Interrupt::Cancelled, - () = deadline => Interrupt::DeadlineElapsed, + () = deadline_elapsed(self.deadline) => Interrupt::DeadlineElapsed, } } } @@ -422,10 +389,3 @@ fn lost(error: &DriverError) -> bool { ErrorCategory::Network | ErrorCategory::ConnectionLost | ErrorCategory::Tls ) } - -async fn until(deadline: Option) { - match deadline { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } -} diff --git a/core/crates/drivers/cassandra/src/stream_read.rs b/core/crates/drivers/cassandra/src/stream_read.rs index 143e06555b..363de8a1b4 100644 --- a/core/crates/drivers/cassandra/src/stream_read.rs +++ b/core/crates/drivers/cassandra/src/stream_read.rs @@ -5,8 +5,7 @@ use scylla::statement::unprepared::Statement as CqlStatement; use tablepro_core::sql_syntax::script::{LexicalSettings, ScriptPlan}; use tablepro_core::sql_syntax::{SqlGrammar, StatementAccess, statement_access}; use tablepro_core::{ - DriverError, LossPhase, ReadOnlyRefusal, ReadStatement, ResultEvent, ResultSink, SinkFlow, StopRequest, - StreamSummary, Truncation, Value, + DriverError, LossPhase, ReadEmitter, ReadOnlyRefusal, ReadStatement, ResultSink, StopRequest, StreamSummary, Value, }; use crate::call::stoppable; @@ -14,8 +13,6 @@ use crate::errors::execution_error; use crate::rows::{ColumnsRead, MAX_PAGE_ROWS, next_state, page_size}; use crate::session::CqlLink; -const BATCH_ROWS: usize = 256; - /// CQL has no read-only session, so user SQL that is not a plain read is /// refused before it is sent; generated reads are SELECTs. Each page is /// asked for once the sink took the last. @@ -25,12 +22,11 @@ pub(crate) async fn stream( sink: &mut dyn ResultSink, stop: &StopRequest, ) -> Result { - let mut emitter = Emitter { sink, rows: 0 }; + let mut emitter = ReadEmitter::new(sink); match read { ReadStatement::Generated(statement) => { let mut paging = PagingState::start(); let mut columns: Option = None; - let mut rows = 0; loop { let page = link.page(statement, page_size(MAX_PAGE_ROWS), paging); let (result, response) = stoppable(stop, page).await?; @@ -39,23 +35,19 @@ pub(crate) async fn stream( .map_err(|error| DriverError::Protocol(error.to_string()))?; if columns.is_none() { let read = ColumnsRead::of(page_rows.column_specs()); - emitter - .send(ResultEvent::ResultSetStarted { - columns: read.columns.clone(), - }) - .await?; + emitter.start(read.columns.clone()).await?; columns = Some(read); } let decoded = columns .as_ref() .map_or(Ok(Vec::new()), |read| read.decode(&page_rows))?; - rows += emitter.rows(decoded).await?; + emit_page(&mut emitter, decoded).await?; match next_state(response) { Some(next) => paging = next, None => break, } } - emitter.finished(rows).await?; + emitter.finish().await?; } ReadStatement::User(sql) => { if statement_access(sql.as_str(), SqlGrammar::Cql) != StatementAccess::Read { @@ -71,20 +63,19 @@ pub(crate) async fn stream( } } } - Ok(StreamSummary::new(emitter.rows)) + Ok(StreamSummary::new(emitter.rows())) } async fn user_statement( link: &CqlLink, text: &str, - emitter: &mut Emitter<'_>, + emitter: &mut ReadEmitter<'_>, stop: &StopRequest, ) -> Result<(), DriverError> { let mut statement = CqlStatement::new(text); statement.set_page_size(page_size(MAX_PAGE_ROWS)); let mut paging = PagingState::start(); let mut columns: Option = None; - let mut rows = 0; loop { let page = link.session().query_single_page(statement.clone(), (), paging); let (result, response) = stoppable(stop, async { @@ -99,56 +90,24 @@ async fn user_statement( .map_err(|error| DriverError::Protocol(error.to_string()))?; if columns.is_none() { let read = ColumnsRead::of(page_rows.column_specs()); - emitter - .send(ResultEvent::ResultSetStarted { - columns: read.columns.clone(), - }) - .await?; + emitter.start(read.columns.clone()).await?; columns = Some(read); } let decoded = columns .as_ref() .map_or(Ok(Vec::new()), |read| read.decode(&page_rows))?; - rows += emitter.rows(decoded).await?; + emit_page(emitter, decoded).await?; match next_state(response) { Some(next) => paging = next, - None => return emitter.finished(rows).await, + None => return emitter.finish().await, } } } -struct Emitter<'a> { - sink: &'a mut dyn ResultSink, - rows: u64, -} - -impl Emitter<'_> { - async fn rows(&mut self, rows: Vec>) -> Result { - let count = rows.len() as u64; - let mut rows = rows.into_iter().peekable(); - while rows.peek().is_some() { - let batch: Vec> = rows.by_ref().take(BATCH_ROWS).collect(); - self.send(ResultEvent::Rows(batch)).await?; - } - self.rows += count; - Ok(count) - } - - async fn finished(&mut self, rows: u64) -> Result<(), DriverError> { - self.send(ResultEvent::ResultSetFinished { - retained: rows, - total_rows: Some(rows), - truncation: Truncation::Complete, - }) - .await - } - - /// A consumer that went away ends the read: no further page is asked - /// for. - async fn send(&mut self, event: ResultEvent) -> Result<(), DriverError> { - match self.sink.accept(event).await { - SinkFlow::Continue => Ok(()), - SinkFlow::ConsumerGone => Err(DriverError::Cancelled), - } +// Nothing is carried to the next page: each page's last rows go out before it is asked for. +async fn emit_page(emitter: &mut ReadEmitter<'_>, rows: Vec>) -> Result<(), DriverError> { + for row in rows { + emitter.row(row).await?; } + emitter.flush().await } diff --git a/core/crates/drivers/cassandra/src/write_batch.rs b/core/crates/drivers/cassandra/src/write_batch.rs index a6ec964c05..a278a7ad32 100644 --- a/core/crates/drivers/cassandra/src/write_batch.rs +++ b/core/crates/drivers/cassandra/src/write_batch.rs @@ -2,9 +2,7 @@ //! around them. use tablepro_core::statement::{GuardedStatement, RowGuard, Statement}; -use tablepro_core::{ - DriverError, ReadOnlyRefusal, ServerCode, SessionFate, StopRequest, WriteBatch, WriteLedger, WriteReport, -}; +use tablepro_core::{DriverError, ServerCode, SessionFate, StopRequest, WriteBatch, WriteLedger, WriteReport}; use crate::call::{stoppable, stopped}; use crate::rows::applied; @@ -16,10 +14,7 @@ use crate::session::CqlLink; /// the fact, so a guard that expects no row cannot be held: the row it /// finds is already written. pub(crate) fn precheck(batch: &WriteBatch, read_only: bool) -> Result<(), DriverError> { - if read_only { - return Err(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)); - } - batch.foreign_keys.require_enforced()?; + batch.precheck(read_only)?; let unprovable = batch.steps.iter().position(|step| match step.guard { RowGuard::AffectedExactly(rows) => rows != 1 || !reports_applied(&step.statement), RowGuard::None | RowGuard::ProbeExactly { .. } => false, @@ -136,7 +131,9 @@ fn may_have_applied(error: &DriverError) -> bool { mod tests { use tablepro_core::meta::TableRef; use tablepro_core::statement::StatementBuilder; - use tablepro_core::{ForeignKeyCheck, ForeignKeyMode, LossPhase, ServerDiagnostics, UnsupportedFeature, WriteKind}; + use tablepro_core::{ + ForeignKeyCheck, ForeignKeyMode, LossPhase, ReadOnlyRefusal, ServerDiagnostics, UnsupportedFeature, WriteKind, + }; use super::*; diff --git a/core/crates/drivers/clickhouse/src/editor_run.rs b/core/crates/drivers/clickhouse/src/editor_run.rs index 74ff6b8268..28a1e1818f 100644 --- a/core/crates/drivers/clickhouse/src/editor_run.rs +++ b/core/crates/drivers/clickhouse/src/editor_run.rs @@ -4,7 +4,7 @@ use std::time::Duration; use tablepro_core::column::ResultColumn; use tablepro_core::{ DriverError, ErrorCategory, LossPhase, ResultEvent, ResultSink, RowBatch, RowLimit, RunEnd, RunOptions, RunSummary, - SinkFlow, TimeoutPhase, TransactionState, Truncation, UserSql, Value, + SinkFlow, TimeoutPhase, TransactionState, Truncation, UserSql, Value, deadline_elapsed, }; use tokio::time::Instant; use tokio_util::sync::CancellationToken; @@ -167,7 +167,7 @@ impl EditorRun { tracing::debug!(%error, "waiting for a stopped editor query to end failed"); } } - () = reached(give_up) => { + () = deadline_elapsed(give_up) => { tracing::debug!("a stopped editor query did not end within the cancel grace"); } } @@ -274,14 +274,6 @@ async fn kill_within(control: &clickhouse::Client, query_id: Uuid, grace: Durati } } -/// Ends at `at`, or never without one. -async fn reached(at: Option) { - match at { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } -} - /// What stops a run, and when the stop was sent. struct Stop { cancel: CancellationToken, @@ -308,7 +300,7 @@ impl Stop { tokio::select! { () = self.cancel.cancelled() => Interrupt::Cancelled, () = self.shutdown.cancelled() => Interrupt::Cancelled, - () = reached(self.deadline) => Interrupt::DeadlineElapsed, + () = deadline_elapsed(self.deadline) => Interrupt::DeadlineElapsed, } } @@ -323,7 +315,7 @@ impl Stop { } async fn gave_up(&self) { - reached(self.give_up).await; + deadline_elapsed(self.give_up).await; } /// How a stopped run ends. The server's 394 or its own timeout is the diff --git a/core/crates/drivers/clickhouse/src/editor_session.rs b/core/crates/drivers/clickhouse/src/editor_session.rs index 5b4af247e8..fac6f93710 100644 --- a/core/crates/drivers/clickhouse/src/editor_session.rs +++ b/core/crates/drivers/clickhouse/src/editor_session.rs @@ -3,8 +3,9 @@ use std::time::Duration; use async_trait::async_trait; use tablepro_core::{ - CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState, LossPhase, - ResultSink, RunEnd, RunOptions, RunSummary, TimeoutPhase, TransactionState, UserSql, + CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState, + EditorSessionStatus, LossPhase, ResultSink, RunEnd, RunOptions, RunSummary, TimeoutPhase, TransactionState, + UserSql, deadline_elapsed, }; use tokio_util::sync::CancellationToken; use uuid::Uuid; @@ -13,7 +14,6 @@ use crate::editor_run::EditorRun; use crate::endpoint::ClickHouseEndpoint; use crate::lingering_query::LingeringQuery; use crate::result_reader::drain; -use crate::session_status::SessionStatus; /// One editor tab's ClickHouse HTTP session. /// @@ -31,7 +31,7 @@ pub(crate) struct ClickHouseEditorSession { statement_timeout: Option, bounds_on_server: bool, grace: Duration, - status: Arc, + status: Arc, shutdown: CancellationToken, lingering: Arc, } @@ -71,7 +71,7 @@ impl ClickHouseEditorSession { statement_timeout: options.statement_timeout, bounds_on_server: endpoint.bounds_reads(), grace: liveness.cancel_grace, - status: Arc::new(SessionStatus::new()), + status: Arc::new(EditorSessionStatus::new()), shutdown: CancellationToken::new(), lingering: Arc::new(LingeringQuery::default()), })) @@ -95,7 +95,7 @@ impl EditorSession for ClickHouseEditorSession { let answered = tokio::select! { biased; () = options.cancel().cancelled() => return Err(DriverError::Cancelled), - () = until(options.deadline()) => return Err(DriverError::Timeout { + () = deadline_elapsed(options.deadline()) => return Err(DriverError::Timeout { phase: TimeoutPhase::Statement, server_cancelled: false, }), @@ -178,13 +178,6 @@ impl EditorSession for ClickHouseEditorSession { } } -async fn until(deadline: Option) { - match deadline { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } -} - #[cfg(test)] mod tests { use async_trait::async_trait; diff --git a/core/crates/drivers/clickhouse/src/lib.rs b/core/crates/drivers/clickhouse/src/lib.rs index acd1d1e18c..c74fc7a8eb 100644 --- a/core/crates/drivers/clickhouse/src/lib.rs +++ b/core/crates/drivers/clickhouse/src/lib.rs @@ -33,7 +33,6 @@ mod param_value; mod result_origin; mod result_reader; mod row_seed; -mod session_status; mod stream_read; mod transport_connector; mod transport_io; diff --git a/core/crates/drivers/clickhouse/src/stream_read.rs b/core/crates/drivers/clickhouse/src/stream_read.rs index c3b28e6a59..6cd86b0dbf 100644 --- a/core/crates/drivers/clickhouse/src/stream_read.rs +++ b/core/crates/drivers/clickhouse/src/stream_read.rs @@ -1,10 +1,8 @@ -use tablepro_core::{DriverError, ReadStatement, ResultEvent, ResultSink, SinkFlow, StreamSummary, Truncation, Value}; +use tablepro_core::{DriverError, ReadEmitter, ReadStatement, ResultSink, StreamSummary}; use crate::call_client::CallClient; use crate::result_reader::{ReadEvent, ResultReader}; -const BATCH_ROWS: usize = 256; - /// Every row of a read, into the sink. The call's client carries /// `readonly`, 1 for user SQL, so SQL that writes is refused by the /// server for the read's whole length. @@ -18,62 +16,17 @@ pub(crate) async fn stream( ReadStatement::User(sql) => calls.raw(sql.as_str())?, }; let mut reader = ResultReader::open(query)?; - let mut emitter = Emitter { - sink, - batch: Vec::new(), - rows: 0, - }; + // A consumer that went away ends the read, and dropping the body stops it on the server. + let mut emitter = ReadEmitter::new(sink); loop { match reader.next_event().await? { - ReadEvent::Columns(columns) => emitter.send(ResultEvent::ResultSetStarted { columns }).await?, + ReadEvent::Columns(columns) => emitter.start(columns).await?, ReadEvent::Row(row) => emitter.row(row).await?, ReadEvent::End => break, } } if reader.has_result_set() { - emitter.flush().await?; - let rows = emitter.rows; - emitter - .send(ResultEvent::ResultSetFinished { - retained: rows, - total_rows: Some(rows), - truncation: Truncation::Complete, - }) - .await?; - } - Ok(StreamSummary::new(emitter.rows)) -} - -struct Emitter<'a> { - sink: &'a mut dyn ResultSink, - batch: Vec>, - rows: u64, -} - -impl Emitter<'_> { - async fn row(&mut self, values: Vec) -> Result<(), DriverError> { - self.batch.push(values); - self.rows += 1; - if self.batch.len() >= BATCH_ROWS { - self.flush().await?; - } - Ok(()) - } - - async fn flush(&mut self) -> Result<(), DriverError> { - if self.batch.is_empty() { - return Ok(()); - } - let rows = std::mem::take(&mut self.batch); - self.send(ResultEvent::Rows(rows)).await - } - - /// A consumer that went away ends the read: the rows would go - /// nowhere, and dropping the body stops the read on the server. - async fn send(&mut self, event: ResultEvent) -> Result<(), DriverError> { - match self.sink.accept(event).await { - SinkFlow::Continue => Ok(()), - SinkFlow::ConsumerGone => Err(DriverError::Cancelled), - } + emitter.finish().await?; } + Ok(StreamSummary::new(emitter.rows())) } diff --git a/core/crates/drivers/clickhouse/src/write_batch.rs b/core/crates/drivers/clickhouse/src/write_batch.rs index 89138aea7c..bbd6bd41cf 100644 --- a/core/crates/drivers/clickhouse/src/write_batch.rs +++ b/core/crates/drivers/clickhouse/src/write_batch.rs @@ -3,9 +3,7 @@ use std::sync::Arc; use clickhouse::error::Error as ClickHouseError; use tablepro_core::meta::TableRef; use tablepro_core::statement::{GuardedStatement, RowGuard, Statement}; -use tablepro_core::{ - CommitToken, DriverError, ReadOnlyRefusal, SessionFate, StopRequest, WriteBatch, WriteLedger, WriteReport, -}; +use tablepro_core::{CommitToken, DriverError, SessionFate, StopRequest, WriteBatch, WriteLedger, WriteReport}; use uuid::Uuid; use crate::call_client::CallClient; @@ -19,10 +17,7 @@ use crate::write_error_class::{WriteErrorClass, classify}; /// writes, ClickHouse cannot suspend foreign keys it does not have, and /// a mutation reports no row count for an exact guard to check. pub(crate) fn precheck(batch: &WriteBatch, read_only: bool) -> Result<(), DriverError> { - if read_only { - return Err(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)); - } - batch.foreign_keys.require_enforced()?; + batch.precheck(read_only)?; match batch .steps .iter() @@ -182,7 +177,7 @@ async fn count(calls: &CallClient, probe: &Statement) -> Result Stop::Cancelled, - () = elapsed(deadline) => Stop::DeadlineElapsed, + () = deadline_elapsed(deadline) => Stop::DeadlineElapsed, outcome = &mut running => { return match outcome { Ok(outcome) if outcome.halted => Ok(halted_end(self.stop_due(options, deadline))), @@ -278,13 +278,6 @@ impl Drop for LoseOnDrop<'_> { } } -async fn elapsed(deadline: Option) { - match deadline { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } -} - fn finished(outcome: Result) -> Result { match outcome { Ok(outcome) => Ok(completed(outcome)), @@ -359,7 +352,7 @@ impl EditorSession for DuckDbEditorSession { let mut held = tokio::select! { biased; () = options.cancel().cancelled() => return Err(DriverError::Cancelled), - () = elapsed(options.deadline()) => { + () = deadline_elapsed(options.deadline()) => { return Err(DriverError::Timeout { phase: TimeoutPhase::Statement, server_cancelled: false }); } held = shared.call.lock() => held, diff --git a/core/crates/drivers/mongodb/src/cursor_rows.rs b/core/crates/drivers/mongodb/src/cursor_rows.rs index eba4173ac4..9fb295716d 100644 --- a/core/crates/drivers/mongodb/src/cursor_rows.rs +++ b/core/crates/drivers/mongodb/src/cursor_rows.rs @@ -1,10 +1,12 @@ use bson::Document; use mongodb::{ClientSession, SessionCursor}; -use tablepro_core::{ByteLimit, DriverError, LossPhase, ResultEvent, ResultSink, RowLimit, SinkFlow, Truncation}; +use tablepro_core::{ + ByteLimit, DriverError, LossPhase, ResultEvent, ResultSink, RowBatch, RowLimit, SinkFlow, Truncation, +}; use crate::call::ReadStop; use crate::endpoint::MongoEndpoint; -use crate::rows::{BATCH_ROWS, Layout}; +use crate::rows::Layout; use crate::shell_command::Columns; // Found columns hold every kept document before the first event, so no sink can stop them at the byte limit. @@ -78,7 +80,7 @@ impl<'a> Read<'a> { /// ends when it does: a full `room` reads one more to say whether the /// result was cut. async fn batch(&mut self, room: u64) -> Result<(Vec, Option), DriverError> { - let take = usize::try_from(room).unwrap_or(usize::MAX).min(BATCH_ROWS); + let take = usize::try_from(room).unwrap_or(usize::MAX).min(RowBatch::MAX_ROWS); let mut documents = Vec::with_capacity(take); while documents.len() < take { match self.next().await? { @@ -135,7 +137,7 @@ async fn discovered_kept( return Ok((SinkFlow::ConsumerGone, 0)); } let retained = documents.len() as u64; - for batch in documents.chunks(BATCH_ROWS) { + for batch in documents.chunks(RowBatch::MAX_ROWS) { let rows = batch.iter().map(|document| layout.row(document)).collect(); if sink.accept(ResultEvent::Rows(rows)).await == SinkFlow::ConsumerGone { return Ok((SinkFlow::ConsumerGone, retained)); @@ -232,7 +234,7 @@ async fn every( loop { let mut documents = Vec::new(); let mut exhausted = false; - while documents.len() < BATCH_ROWS { + while documents.len() < RowBatch::MAX_ROWS { match read.next().await? { Some(document) => documents.push(document), None => { diff --git a/core/crates/drivers/mongodb/src/editor_run.rs b/core/crates/drivers/mongodb/src/editor_run.rs index edc1eb96f5..4fd84abb0f 100644 --- a/core/crates/drivers/mongodb/src/editor_run.rs +++ b/core/crates/drivers/mongodb/src/editor_run.rs @@ -9,7 +9,7 @@ use tablepro_core::sql_syntax::StatementAccess; use tablepro_core::sql_syntax::mongo::{access_of, parse_statement, statement_ranges}; use tablepro_core::{ DriverError, ErrorCategory, ReadOnlyRefusal, ResultSink, RunEnd, RunOptions, RunSummary, SinkFlow, StopReason, - StopRequest, TimeoutPhase, TransactionState, UserSql, + StopRequest, TimeoutPhase, TransactionState, UserSql, deadline_elapsed, }; use tokio::time::Instant; use tokio_util::sync::CancellationToken; @@ -185,7 +185,7 @@ impl EditorRun { }), () = options.cancel.cancelled() => ControlFlow::Continue(Interrupt::Cancelled), () = self.shutdown.cancelled() => ControlFlow::Continue(Interrupt::Cancelled), - () = until(deadline) => ControlFlow::Continue(Interrupt::DeadlineElapsed), + () = deadline_elapsed(deadline) => ControlFlow::Continue(Interrupt::DeadlineElapsed), }; match interrupt { ControlFlow::Break(ran) => ran, @@ -241,10 +241,3 @@ fn summary(started: Instant, end: RunEnd) -> RunSummary { transaction_state: TransactionState::Idle, } } - -async fn until(deadline: Option) { - match deadline { - Some(deadline) => tokio::time::sleep_until(deadline).await, - None => std::future::pending().await, - } -} diff --git a/core/crates/drivers/mongodb/src/editor_session.rs b/core/crates/drivers/mongodb/src/editor_session.rs index 121b1f6026..5f5e43b08b 100644 --- a/core/crates/drivers/mongodb/src/editor_session.rs +++ b/core/crates/drivers/mongodb/src/editor_session.rs @@ -4,14 +4,13 @@ use std::time::Duration; use async_trait::async_trait; use mongodb::Client; use tablepro_core::{ - CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState, LossPhase, - ResultSink, RunOptions, RunSummary, TransactionState, UserSql, + CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState, + EditorSessionStatus, LossPhase, ResultSink, RunOptions, RunSummary, TransactionState, UserSql, }; use tokio_util::sync::CancellationToken; use crate::editor_run::EditorRun; use crate::endpoint::{ClientUse, MongoEndpoint}; -use crate::session_status::SessionStatus; /// One editor tab's own client of the server. /// @@ -23,7 +22,7 @@ pub(crate) struct MongoEditorSession { endpoint: Arc, client: Arc>>, database: Arc>, - status: Arc, + status: Arc, read_only: bool, statement_timeout: Option, shutdown: CancellationToken, @@ -46,7 +45,7 @@ impl MongoEditorSession { endpoint, client: Arc::new(Mutex::new(Some(client))), database: Arc::new(Mutex::new(database)), - status: Arc::new(SessionStatus::new()), + status: Arc::new(EditorSessionStatus::new()), read_only, statement_timeout: options.statement_timeout, shutdown: CancellationToken::new(), diff --git a/core/crates/drivers/mongodb/src/lib.rs b/core/crates/drivers/mongodb/src/lib.rs index 98745b90fb..534253b0ad 100644 --- a/core/crates/drivers/mongodb/src/lib.rs +++ b/core/crates/drivers/mongodb/src/lib.rs @@ -29,7 +29,6 @@ mod nested_document; mod relay; mod rows; mod server_version; -mod session_status; mod shell_command; mod shell_find; mod shell_write; diff --git a/core/crates/drivers/mongodb/src/rows.rs b/core/crates/drivers/mongodb/src/rows.rs index b864173ab0..99ce702a8a 100644 --- a/core/crates/drivers/mongodb/src/rows.rs +++ b/core/crates/drivers/mongodb/src/rows.rs @@ -6,7 +6,9 @@ use mongodb::ClientSession; use tablepro_core::column::{ColumnType, ResultColumn}; use tablepro_core::document::NUMBER_TYPE; use tablepro_core::value::Value; -use tablepro_core::{DriverError, QueryResult, ResultEvent, ResultSink, RowLimit, ServerNotice, SinkFlow, Truncation}; +use tablepro_core::{ + DriverError, QueryResult, ResultEvent, ResultSink, RowBatch, RowLimit, ServerNotice, SinkFlow, Truncation, +}; use crate::call::ReadStop; use crate::cells::cell; @@ -16,10 +18,6 @@ use crate::execute::Source; use crate::field_types::{column_type, shared_type, type_alias}; use crate::shell_command::{Columns, NamedColumn}; -/// Rows per `ResultEvent::Rows`. The sink is awaited per batch, so a slow -/// grid slows the read instead of growing a queue. -pub(crate) const BATCH_ROWS: usize = 256; - /// The columns documents are laid out in, which a layout whose fields /// are found from the documents adds to. #[derive(Debug, Clone)] @@ -258,7 +256,7 @@ async fn emit_documents( .collect::>() .into_iter(); loop { - let batch: Vec<_> = rows.by_ref().take(BATCH_ROWS).collect(); + let batch: Vec<_> = rows.by_ref().take(RowBatch::MAX_ROWS).collect(); if batch.is_empty() { break; } diff --git a/core/crates/drivers/mongodb/src/session_status.rs b/core/crates/drivers/mongodb/src/session_status.rs deleted file mode 100644 index 6f520011cc..0000000000 --- a/core/crates/drivers/mongodb/src/session_status.rs +++ /dev/null @@ -1,74 +0,0 @@ -use std::sync::atomic::{AtomicU8, Ordering}; - -use tablepro_core::{DriverError, EditorSessionState, LossPhase}; - -const READY: u8 = 0; -const RUNNING: u8 = 1; -const LOST: u8 = 2; - -/// What an editor session handle answers without waiting for a run. -#[derive(Debug)] -pub(crate) struct SessionStatus { - state: AtomicU8, -} - -impl SessionStatus { - pub(crate) fn new() -> Self { - Self { - state: AtomicU8::new(READY), - } - } - - pub(crate) fn state(&self) -> EditorSessionState { - match self.state.load(Ordering::SeqCst) { - READY => EditorSessionState::Ready, - RUNNING => EditorSessionState::Running, - _ => EditorSessionState::Lost, - } - } - - /// Claim the session for one run: one statement at a time, in the - /// database the run before it chose. - pub(crate) fn begin(&self) -> Result<(), DriverError> { - match self - .state - .compare_exchange(READY, RUNNING, Ordering::SeqCst, Ordering::SeqCst) - { - Ok(_) => Ok(()), - Err(RUNNING) => Err(DriverError::EditorSessionBusy), - Err(_) => Err(DriverError::ConnectionLost { - during: LossPhase::Idle, - }), - } - } - - pub(crate) fn finish(&self) { - let _ = self - .state - .compare_exchange(RUNNING, READY, Ordering::SeqCst, Ordering::SeqCst); - } - - pub(crate) fn lose(&self) { - self.state.store(LOST, Ordering::SeqCst); - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn a_second_run_is_busy_and_a_lost_session_refuses_runs() { - let status = SessionStatus::new(); - assert!(status.begin().is_ok()); - assert_eq!(status.begin(), Err(DriverError::EditorSessionBusy)); - - status.finish(); - assert_eq!(status.state(), EditorSessionState::Ready); - - status.lose(); - assert!(matches!(status.begin(), Err(DriverError::ConnectionLost { .. }))); - status.finish(); - assert_eq!(status.state(), EditorSessionState::Lost); - } -} diff --git a/core/crates/drivers/mongodb/src/write_batch.rs b/core/crates/drivers/mongodb/src/write_batch.rs index e10a59be3e..7f9b50987b 100644 --- a/core/crates/drivers/mongodb/src/write_batch.rs +++ b/core/crates/drivers/mongodb/src/write_batch.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use mongodb::{Client, ClientSession}; use tablepro_core::sql_syntax::mongo::ShellStatement; use tablepro_core::statement::{GuardedStatement, RowGuard}; -use tablepro_core::{DriverError, ReadOnlyRefusal, SessionFate, StopRequest, WriteBatch, WriteLedger, WriteReport}; +use tablepro_core::{DriverError, SessionFate, StopRequest, WriteBatch, WriteLedger, WriteReport}; use crate::call::generated; use crate::endpoint::MongoEndpoint; @@ -12,11 +12,7 @@ use crate::execute::{Source, start, start_write}; /// Refuse a batch before anything is sent: a read-only connection never /// writes, and MongoDB has no foreign keys to suspend. pub(crate) fn precheck(batch: &WriteBatch, read_only: bool) -> Result<(), DriverError> { - if read_only { - return Err(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)); - } - batch.foreign_keys.require_enforced()?; - Ok(()) + batch.precheck(read_only) } /// Everything one save needs once its task runs. diff --git a/core/crates/drivers/mssql/src/editor_session.rs b/core/crates/drivers/mssql/src/editor_session.rs index 01ce460613..aab13853af 100644 --- a/core/crates/drivers/mssql/src/editor_session.rs +++ b/core/crates/drivers/mssql/src/editor_session.rs @@ -7,6 +7,7 @@ use tablepro_core::sql_syntax::{SqlGrammar, may_change_database}; use tablepro_core::{ CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState, LossPhase, ResultSink, RunEnd, RunOptions, RunSummary, StopReason, StopRequest, TimeoutPhase, TransactionState, UserSql, + deadline_elapsed, }; use tokio::sync::OwnedMutexGuard; use tokio::time::Instant; @@ -173,7 +174,7 @@ impl Shared { biased; outcome = &mut running => return Some(outcome), () = options.cancel.cancelled() => request.request(StopReason::Cancelled), - () = elapsed(deadline) => request.request(StopReason::DeadlineElapsed), + () = deadline_elapsed(deadline) => request.request(StopReason::DeadlineElapsed), } tokio::time::timeout(self.cancel_grace, running).await.ok() } @@ -198,13 +199,6 @@ impl Shared { } } -async fn elapsed(deadline: Option) { - match deadline { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } -} - #[async_trait] impl EditorSession for MssqlEditorSession { fn id(&self) -> EditorSessionId { @@ -253,7 +247,7 @@ impl EditorSession for MssqlEditorSession { let mut held = tokio::select! { biased; () = options.cancel().cancelled() => return Err(DriverError::Cancelled), - () = elapsed(options.deadline()) => { + () = deadline_elapsed(options.deadline()) => { return Err(DriverError::Timeout { phase: TimeoutPhase::Statement, server_cancelled: false }); } held = shared.link.lock() => held, @@ -267,7 +261,7 @@ impl EditorSession for MssqlEditorSession { let used = tokio::select! { biased; () = options.cancel().cancelled() => None, - () = elapsed(options.deadline()) => None, + () = deadline_elapsed(options.deadline()) => None, used = using => Some(used), }; match used { @@ -302,7 +296,7 @@ impl EditorSession for MssqlEditorSession { let mut held = tokio::select! { biased; () = options.cancel().cancelled() => return Err(DriverError::Cancelled), - () = elapsed(options.deadline()) => { + () = deadline_elapsed(options.deadline()) => { return Err(DriverError::Timeout { phase: TimeoutPhase::Statement, server_cancelled: false }); } held = shared.link.lock() => held, @@ -316,7 +310,7 @@ impl EditorSession for MssqlEditorSession { let answer = tokio::select! { biased; () = options.cancel().cancelled() => None, - () = elapsed(options.deadline()) => None, + () = deadline_elapsed(options.deadline()) => None, answer = asking => Some(answer), }; match answer { diff --git a/core/crates/drivers/mssql/src/stream_read.rs b/core/crates/drivers/mssql/src/stream_read.rs index b53d576a3f..fcc9c1ed58 100644 --- a/core/crates/drivers/mssql/src/stream_read.rs +++ b/core/crates/drivers/mssql/src/stream_read.rs @@ -1,7 +1,7 @@ use std::sync::Arc; use tablepro_core::column::ResultColumn; -use tablepro_core::{ReadStatement, ResultEvent, ResultSink, SinkFlow, StreamSummary, Truncation, Value}; +use tablepro_core::{DriverError, ReadEmitter, ReadStatement, ResultSink, StreamSummary}; use tiberius::QueryItem; use crate::catalog::result_column; @@ -11,8 +11,6 @@ use crate::in_band_request::{Interrupt, Watch}; use crate::physical::MssqlClient; use crate::read_only_guard::{guarded_error, refuse_writes, wrap}; -const BATCH_ROWS: usize = 256; - /// Every row of a read, into the sink. User SQL must be a plain read, /// and the whole read runs inside a transaction that is rolled back, so /// a write that slips past the check still does not land. @@ -31,36 +29,38 @@ pub(crate) async fn stream( }; let guarded = wrap(sql); let refs = as_sql(¶ms); - let mut emitter = Emitter { - sink, - batch: Vec::new(), - open: false, - set_rows: 0, - rows: 0, - }; + let mut emitter = ReadEmitter::new(sink); let mut stream = watch .start(client.query(guarded.as_str(), &refs)) .await .map_err(guard)?; while let Some(item) = watch.next(&mut stream).await.map_err(guard)? { - let flow = match item { + let emitted = match item { QueryItem::Metadata(metadata) => { let columns: Arc<[ResultColumn]> = metadata.columns().iter().map(result_column).collect(); - emitter.start(columns).await + next_set(&mut emitter, columns).await } QueryItem::Row(row) => emitter.row(decode_row(&row)).await, }; - if flow == SinkFlow::ConsumerGone { - // The connection is closed after this call, which ends the - // response on the server too. + // The emitter fails only when the consumer went away. The + // connection is closed after this call, which ends the response + // on the server too. + if emitted.is_err() { watch.spoil(); - return Ok(StreamSummary::new(emitter.rows)); + return Ok(StreamSummary::new(emitter.rows())); } } - if emitter.finish().await == SinkFlow::ConsumerGone { + if emitter.is_open() && emitter.finish().await.is_err() { watch.spoil(); } - Ok(StreamSummary::new(emitter.rows)) + Ok(StreamSummary::new(emitter.rows())) +} + +async fn next_set(emitter: &mut ReadEmitter<'_>, columns: Arc<[ResultColumn]>) -> Result<(), DriverError> { + if emitter.is_open() { + emitter.finish().await?; + } + emitter.start(columns).await } fn guard(interrupt: Interrupt) -> Interrupt { @@ -69,58 +69,3 @@ fn guard(interrupt: Interrupt) -> Interrupt { other => other, } } - -struct Emitter<'a> { - sink: &'a mut dyn ResultSink, - batch: Vec>, - open: bool, - set_rows: u64, - rows: u64, -} - -impl Emitter<'_> { - async fn start(&mut self, columns: Arc<[ResultColumn]>) -> SinkFlow { - if self.finish().await == SinkFlow::ConsumerGone { - return SinkFlow::ConsumerGone; - } - self.open = true; - self.sink.accept(ResultEvent::ResultSetStarted { columns }).await - } - - async fn row(&mut self, values: Vec) -> SinkFlow { - self.batch.push(values); - self.set_rows += 1; - self.rows += 1; - if self.batch.len() < BATCH_ROWS { - return SinkFlow::Continue; - } - self.sink - .accept(ResultEvent::Rows(std::mem::take(&mut self.batch))) - .await - } - - /// Close the result set that is open, if one is. - async fn finish(&mut self) -> SinkFlow { - if !self.open { - return SinkFlow::Continue; - } - if !self.batch.is_empty() - && self - .sink - .accept(ResultEvent::Rows(std::mem::take(&mut self.batch))) - .await - == SinkFlow::ConsumerGone - { - return SinkFlow::ConsumerGone; - } - self.open = false; - let retained = std::mem::take(&mut self.set_rows); - self.sink - .accept(ResultEvent::ResultSetFinished { - retained, - total_rows: Some(retained), - truncation: Truncation::Complete, - }) - .await - } -} diff --git a/core/crates/drivers/mssql/src/write_batch.rs b/core/crates/drivers/mssql/src/write_batch.rs index c0c120efda..547c9525dc 100644 --- a/core/crates/drivers/mssql/src/write_batch.rs +++ b/core/crates/drivers/mssql/src/write_batch.rs @@ -3,8 +3,7 @@ use std::sync::Arc; use futures_util::TryStreamExt; use tablepro_core::statement::{RowGuard, Statement}; use tablepro_core::{ - DriverError, ReadOnlyRefusal, SessionFate, StopRequest, WriteAtomicity, WriteBatch, WriteKind, WriteLedger, - WriteReport, + DriverError, SessionFate, StopRequest, WriteAtomicity, WriteBatch, WriteKind, WriteLedger, WriteReport, }; use tiberius::{Command, CommandItem}; use tokio::time::Instant; @@ -20,10 +19,7 @@ use crate::workspace_call::{catalogue_rows, exact_count}; /// Refuse a batch before anything is sent: a read-only connection never /// writes, and SQL Server cannot suspend foreign keys for one batch. pub(crate) fn precheck(batch: &WriteBatch, read_only: bool) -> Result<(), DriverError> { - if read_only { - return Err(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)); - } - batch.foreign_keys.require_enforced() + batch.precheck(read_only) } /// Whether the batch runs inside one transaction. SQL Server refuses @@ -267,7 +263,7 @@ impl Write<'_> { #[cfg(test)] mod tests { use tablepro_core::meta::TableRef; - use tablepro_core::{ForeignKeyCheck, ForeignKeyMode, UnsupportedFeature}; + use tablepro_core::{ForeignKeyCheck, ForeignKeyMode, ReadOnlyRefusal, UnsupportedFeature}; use super::*; diff --git a/core/crates/drivers/mysql/src/editor_session.rs b/core/crates/drivers/mysql/src/editor_session.rs index 5d395d8658..b5c8ad23aa 100644 --- a/core/crates/drivers/mysql/src/editor_session.rs +++ b/core/crates/drivers/mysql/src/editor_session.rs @@ -9,6 +9,7 @@ use tablepro_core::sql_syntax::{SqlGrammar, may_change_database}; use tablepro_core::{ CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState, LivenessPolicy, LossPhase, ResultSink, RunEnd, RunOptions, RunSummary, TimeoutPhase, TransactionState, UserSql, Value, + deadline_elapsed, }; use tokio::sync::OwnedMutexGuard; use tokio::time::Instant; @@ -221,7 +222,7 @@ impl Shared { () = options.cancel.cancelled() => Stop::Cancelled, () = self.closing.cancelled() => Stop::Cancelled, () = stopped.cancelled() => Stop::Cancelled, - () = elapsed(deadline) => Stop::DeadlineElapsed, + () = deadline_elapsed(deadline) => Stop::DeadlineElapsed, }; stopped.cancel(); let until = Instant::now() + self.liveness.cancel_grace; @@ -320,13 +321,6 @@ fn finished(outcome: Result) -> Result) { - match deadline { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } -} - #[async_trait] impl EditorSession for MysqlEditorSession { fn id(&self) -> EditorSessionId { @@ -383,7 +377,7 @@ impl EditorSession for MysqlEditorSession { let mut guard = tokio::select! { biased; () = options.cancel().cancelled() => return Err(stopped()), - () = elapsed(options.deadline()) => return Err(stopped()), + () = deadline_elapsed(options.deadline()) => return Err(stopped()), guard = shared.held.lock() => guard, }; let Some(held) = guard.as_mut().filter(|_| !shared.lost.load(Ordering::SeqCst)) else { @@ -396,7 +390,7 @@ impl EditorSession for MysqlEditorSession { let used = tokio::select! { biased; () = options.cancel().cancelled() => None, - () = elapsed(options.deadline()) => None, + () = deadline_elapsed(options.deadline()) => None, used = using => Some(used), }; match used { @@ -436,7 +430,7 @@ impl EditorSession for MysqlEditorSession { tokio::select! { biased; () = options.cancel().cancelled() => Err(DriverError::Cancelled), - () = elapsed(options.deadline()) => Err(DriverError::Timeout { + () = deadline_elapsed(options.deadline()) => Err(DriverError::Timeout { phase: TimeoutPhase::Statement, server_cancelled: false, }), diff --git a/core/crates/drivers/mysql/src/stream_read.rs b/core/crates/drivers/mysql/src/stream_read.rs index e1a6d373ba..dd3e269e15 100644 --- a/core/crates/drivers/mysql/src/stream_read.rs +++ b/core/crates/drivers/mysql/src/stream_read.rs @@ -5,9 +5,7 @@ use sqlx::mysql::{MySqlConnection, MySqlDatabaseError}; use sqlx::{AssertSqlSafe, Either, Executor as _, Row as _, Statement as _}; use tablepro_core::column::ResultColumn; use tablepro_core::sql_syntax::{SqlGrammar, StatementAccess, statement_access}; -use tablepro_core::{ - DriverError, ReadOnlyRefusal, ReadStatement, ResultEvent, ResultSink, SinkFlow, StreamSummary, Truncation, Value, -}; +use tablepro_core::{DriverError, ReadEmitter, ReadOnlyRefusal, ReadStatement, ResultSink, StreamSummary}; use crate::catalog::result_column; use crate::decode::decode_row; @@ -17,8 +15,6 @@ use crate::mysql_timestamp_mode::MySqlTimestampMode; use crate::mysql_wire_format::MySqlWireFormat; use crate::workspace_call::{describe, prepare_uncached, prepared}; -const BATCH_ROWS: usize = 256; - /// Every row of a read, into the sink, inside a read-only transaction. /// The connection has no statement timeout: an export can take minutes, /// and the caller's deadline and cancel still stop it. @@ -39,20 +35,18 @@ pub(crate) async fn stream( .execute("START TRANSACTION READ ONLY") .await .map_err(|error| map_error(&error, flavour))?; - let mut emitter = Emitter { - sink, - batch: Vec::new(), - rows: 0, - set_rows: 0, - started: false, - }; + let mut emitter = ReadEmitter::new(sink); let streamed = match read { ReadStatement::Generated(statement) => { let query = prepared(statement)?; - let streamed = emitter - .rows_of(query.fetch(&mut *connection), flavour, MySqlWireFormat::Binary) - .await; - match (streamed, emitter.started) { + let streamed = rows_of( + &mut emitter, + query.fetch(&mut *connection), + flavour, + MySqlWireFormat::Binary, + ) + .await; + match (streamed, emitter.is_open()) { (Ok(()), false) => { let columns = describe(connection, flavour, statement.sql()).await?; emitter.start(columns.into()).await?; @@ -64,9 +58,9 @@ pub(crate) async fn stream( } ReadStatement::User(sql) => { let results = connection.fetch_many(sqlx::raw_sql(AssertSqlSafe(sql.as_str().to_owned()))); - match emitter.results(results, flavour).await { + match results_of(&mut emitter, results, flavour).await { // sqlx gives an empty set as its OK alone, so its columns come from the prepare. - Ok(()) if emitter.rows == 0 && !declared.is_empty() => { + Ok(()) if emitter.rows() == 0 && !declared.is_empty() => { emitter.start(declared.into()).await?; emitter.finish().await } @@ -81,7 +75,7 @@ pub(crate) async fn stream( .map_err(|error| map_error(&error, flavour)); streamed?; committed?; - Ok(StreamSummary::new(emitter.rows)) + Ok(StreamSummary::new(emitter.rows())) } /// User SQL that does anything but read is refused: a write fails in the @@ -123,95 +117,53 @@ async fn prepare_as_one( } } -struct Emitter<'a> { - sink: &'a mut dyn ResultSink, - batch: Vec>, - rows: u64, - set_rows: u64, - started: bool, -} - -impl Emitter<'_> { - async fn rows_of(&mut self, rows: S, flavour: MySqlFlavour, format: MySqlWireFormat) -> Result<(), DriverError> - where - S: futures_util::Stream>, - { - let mut rows = std::pin::pin!(rows); - while let Some(row) = rows.try_next().await.map_err(|error| map_error(&error, flavour))? { - self.row(&row, format).await?; - } - Ok(()) - } - - async fn results(&mut self, results: S, flavour: MySqlFlavour) -> Result<(), DriverError> - where - S: futures_util::Stream< - Item = Result, sqlx::Error>, - >, - { - let mut results = std::pin::pin!(results); - while let Some(item) = results.try_next().await.map_err(|error| map_error(&error, flavour))? { - match item { - Either::Right(row) => self.row(&row, MySqlWireFormat::Text).await?, - Either::Left(_) if self.started => self.finish().await?, - Either::Left(_) => {} - } - } - Ok(()) +async fn rows_of( + emitter: &mut ReadEmitter<'_>, + rows: S, + flavour: MySqlFlavour, + format: MySqlWireFormat, +) -> Result<(), DriverError> +where + S: futures_util::Stream>, +{ + let mut rows = std::pin::pin!(rows); + while let Some(row) = rows.try_next().await.map_err(|error| map_error(&error, flavour))? { + row_of(emitter, &row, format).await?; } + Ok(()) +} - async fn row(&mut self, row: &sqlx::mysql::MySqlRow, format: MySqlWireFormat) -> Result<(), DriverError> { - if !self.started { - let columns: Arc<[ResultColumn]> = row - .columns() - .iter() - .map(|column| result_column(column, MySqlTimestampMode::WorkspaceUtc)) - .collect(); - self.start(columns).await?; - } - self.batch - .push(decode_row(row, format, MySqlTimestampMode::WorkspaceUtc)); - self.rows += 1; - self.set_rows += 1; - if self.batch.len() >= BATCH_ROWS { - self.flush().await?; +async fn results_of(emitter: &mut ReadEmitter<'_>, results: S, flavour: MySqlFlavour) -> Result<(), DriverError> +where + S: futures_util::Stream, sqlx::Error>>, +{ + let mut results = std::pin::pin!(results); + while let Some(item) = results.try_next().await.map_err(|error| map_error(&error, flavour))? { + match item { + Either::Right(row) => row_of(emitter, &row, MySqlWireFormat::Text).await?, + Either::Left(_) if emitter.is_open() => emitter.finish().await?, + Either::Left(_) => {} } - Ok(()) - } - - async fn start(&mut self, columns: Arc<[ResultColumn]>) -> Result<(), DriverError> { - self.started = true; - self.send(ResultEvent::ResultSetStarted { columns }).await } + Ok(()) +} - async fn flush(&mut self) -> Result<(), DriverError> { - if self.batch.is_empty() { - return Ok(()); - } - let rows = std::mem::take(&mut self.batch); - self.send(ResultEvent::Rows(rows)).await +async fn row_of( + emitter: &mut ReadEmitter<'_>, + row: &sqlx::mysql::MySqlRow, + format: MySqlWireFormat, +) -> Result<(), DriverError> { + if !emitter.is_open() { + let columns: Arc<[ResultColumn]> = row + .columns() + .iter() + .map(|column| result_column(column, MySqlTimestampMode::WorkspaceUtc)) + .collect(); + emitter.start(columns).await?; } - - async fn finish(&mut self) -> Result<(), DriverError> { - self.flush().await?; - self.started = false; - let rows = std::mem::take(&mut self.set_rows); - self.send(ResultEvent::ResultSetFinished { - retained: rows, - total_rows: Some(rows), - truncation: Truncation::Complete, - }) + emitter + .row(decode_row(row, format, MySqlTimestampMode::WorkspaceUtc)) .await - } - - /// A consumer that went away ends the read: the rows would go - /// nowhere. - async fn send(&mut self, event: ResultEvent) -> Result<(), DriverError> { - match self.sink.accept(event).await { - SinkFlow::Continue => Ok(()), - SinkFlow::ConsumerGone => Err(DriverError::Cancelled), - } - } } #[cfg(test)] diff --git a/core/crates/drivers/mysql/src/write_batch.rs b/core/crates/drivers/mysql/src/write_batch.rs index d8286a3781..ab024633f4 100644 --- a/core/crates/drivers/mysql/src/write_batch.rs +++ b/core/crates/drivers/mysql/src/write_batch.rs @@ -11,8 +11,8 @@ use sqlx::mysql::MySqlConnection; use sqlx::{AssertSqlSafe, Executor as _}; use tablepro_core::statement::{GuardedStatement, RowGuard, Statement}; use tablepro_core::{ - DriverError, ReadOnlyRefusal, SessionFate, StopRequest, WorkspaceSettings, WriteAtomicity, WriteBatch, WriteKind, - WriteLedger, WriteReport, + DriverError, SessionFate, StopRequest, WorkspaceSettings, WriteAtomicity, WriteBatch, WriteKind, WriteLedger, + WriteReport, }; use crate::cancel::{MySqlStop, acknowledges_stop, interrupted}; @@ -30,10 +30,7 @@ use crate::workspace_call::{count, prepared}; /// writes, and MySQL has no way to suspend foreign keys for a batch the /// way the plan means it. pub(crate) fn precheck(batch: &WriteBatch, read_only: bool) -> Result<(), DriverError> { - if read_only { - return Err(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)); - } - batch.foreign_keys.require_enforced() + batch.precheck(read_only) } /// Everything one write needs once its task holds a connection. @@ -324,7 +321,9 @@ fn acknowledged(request: &StopRequest) -> DriverError { #[cfg(test)] mod tests { use tablepro_core::meta::TableRef; - use tablepro_core::{ForeignKeyCheck, ForeignKeyMode, StopReason, TimeoutPhase, UnsupportedFeature}; + use tablepro_core::{ + ForeignKeyCheck, ForeignKeyMode, ReadOnlyRefusal, StopReason, TimeoutPhase, UnsupportedFeature, + }; use super::*; diff --git a/core/crates/drivers/postgres/src/editor/session_status.rs b/core/crates/drivers/postgres/src/editor/session_status.rs index 10f024d225..a37937a980 100644 --- a/core/crates/drivers/postgres/src/editor/session_status.rs +++ b/core/crates/drivers/postgres/src/editor/session_status.rs @@ -1,48 +1,30 @@ use std::sync::Mutex; -use std::sync::atomic::{AtomicU8, Ordering}; -use tablepro_core::{DriverError, EditorSessionState, LossPhase, TransactionState}; - -const READY: u8 = 0; -const RUNNING: u8 = 1; -const LOST: u8 = 2; +use tablepro_core::{DriverError, EditorSessionState, EditorSessionStatus, TransactionState}; /// What the session handle can answer without asking the actor, which /// may be busy running a script. #[derive(Debug)] pub(crate) struct SessionStatus { - state: AtomicU8, + status: EditorSessionStatus, transaction: Mutex, } impl SessionStatus { pub(crate) fn new() -> Self { Self { - state: AtomicU8::new(READY), + status: EditorSessionStatus::new(), transaction: Mutex::new(TransactionState::Idle), } } pub(crate) fn state(&self) -> EditorSessionState { - match self.state.load(Ordering::SeqCst) { - READY => EditorSessionState::Ready, - RUNNING => EditorSessionState::Running, - _ => EditorSessionState::Lost, - } + self.status.state() } /// Claim the session for one run. pub(crate) fn begin(&self) -> Result<(), DriverError> { - match self - .state - .compare_exchange(READY, RUNNING, Ordering::SeqCst, Ordering::SeqCst) - { - Ok(_) => Ok(()), - Err(RUNNING) => Err(DriverError::EditorSessionBusy), - Err(_) => Err(DriverError::ConnectionLost { - during: LossPhase::Idle, - }), - } + self.status.begin() } pub(crate) fn finish(&self, transaction: TransactionState) { @@ -50,13 +32,11 @@ impl SessionStatus { .transaction .lock() .unwrap_or_else(std::sync::PoisonError::into_inner) = transaction; - let _ = self - .state - .compare_exchange(RUNNING, READY, Ordering::SeqCst, Ordering::SeqCst); + self.status.finish(); } pub(crate) fn lose(&self) { - self.state.store(LOST, Ordering::SeqCst); + self.status.lose(); } pub(crate) fn transaction(&self) -> TransactionState { diff --git a/core/crates/drivers/postgres/src/editor/stop_watch.rs b/core/crates/drivers/postgres/src/editor/stop_watch.rs index 7876565a9a..f30ba9b2c2 100644 --- a/core/crates/drivers/postgres/src/editor/stop_watch.rs +++ b/core/crates/drivers/postgres/src/editor/stop_watch.rs @@ -1,7 +1,7 @@ use std::sync::Arc; use std::time::Duration; -use tablepro_core::DriverError; +use tablepro_core::{DriverError, deadline_elapsed}; use tokio::task::JoinHandle; use tokio::time::Instant; use tokio_postgres::CancelToken; @@ -71,16 +71,10 @@ impl StopWatch { /// Resolves when the run should stop. pub(crate) async fn triggered(&self) -> Interrupt { - let deadline = async { - match self.statement_deadline { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } - }; tokio::select! { () = self.cancel.cancelled() => Interrupt::Cancelled, () = self.shutdown.cancelled() => Interrupt::Cancelled, - () = deadline => Interrupt::DeadlineElapsed, + () = deadline_elapsed(self.statement_deadline) => Interrupt::DeadlineElapsed, } } @@ -110,10 +104,7 @@ impl StopWatch { /// Resolves once the grace after the stop has run out: a statement /// still running then never answered its cancel. pub(crate) async fn gave_up(&self) { - match self.give_up { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } + deadline_elapsed(self.give_up).await; } /// Wait for an outstanding cancel request before anything else goes diff --git a/core/crates/drivers/postgres/src/stream_read.rs b/core/crates/drivers/postgres/src/stream_read.rs index 6adb14a93a..eb1cc92074 100644 --- a/core/crates/drivers/postgres/src/stream_read.rs +++ b/core/crates/drivers/postgres/src/stream_read.rs @@ -5,9 +5,7 @@ use tablepro_core::column::ResultColumn; use tablepro_core::sql_syntax::SqlGrammar; use tablepro_core::sql_syntax::script::{LexicalSettings, ScriptPlan, ScriptToken}; use tablepro_core::statement::Statement; -use tablepro_core::{ - DriverError, ReadOnlyRefusal, ReadStatement, ResultEvent, ResultSink, SinkFlow, StreamSummary, Truncation, Value, -}; +use tablepro_core::{DriverError, ReadEmitter, ReadOnlyRefusal, ReadStatement, ResultSink, StreamSummary, Value}; use tokio_postgres::{Client, SimpleQueryMessage}; use crate::catalog::{result_column, text_column}; @@ -16,8 +14,6 @@ use crate::editor::statement_class::{StatementClass, classify}; use crate::errors::{map_error, read_only_refusal}; use crate::workspace_call::{decode_row, describe}; -const BATCH_ROWS: usize = 256; - /// The read's transaction. Its SELECT takes the snapshot, after which /// the server refuses SET TRANSACTION READ WRITE and any other way of /// making the transaction writable, so user SQL cannot write in it. @@ -38,19 +34,14 @@ pub(crate) async fn stream( refuse_transaction_control(sql.as_str(), conforming)?; } client.batch_execute(BEGIN).await.map_err(|error| map_error(&error))?; - let mut emitter = Emitter { - sink, - batch: Vec::new(), - rows: 0, - set_rows: 0, - }; + let mut emitter = ReadEmitter::new(sink); let streamed = match read { ReadStatement::Generated(statement) => { let rows = client .query_typed_raw(statement.sql(), typed(statement.params())) .await .map_err(|error| map_error(&error))?; - emitter.binary(client, statement, rows).await + binary(&mut emitter, client, statement, rows).await } ReadStatement::User(sql) => { refuse_more_than_one(client, sql.as_str()).await?; @@ -58,13 +49,13 @@ pub(crate) async fn stream( .simple_query_raw(sql.as_str()) .await .map_err(|error| map_error(&error))?; - emitter.text(messages).await + text(&mut emitter, messages).await } }; let committed = client.batch_execute("COMMIT").await.map_err(|error| map_error(&error)); streamed.map_err(read_only_refusal)?; committed?; - Ok(StreamSummary::new(emitter.rows)) + Ok(StreamSummary::new(emitter.rows())) } /// The read-only transaction is the export's whole guarantee, so user @@ -103,103 +94,54 @@ async fn refuse_more_than_one(client: &Client, sql: &str) -> Result<(), DriverEr .map_err(|error| map_error(&error)) } -struct Emitter<'a> { - sink: &'a mut dyn ResultSink, - batch: Vec>, - rows: u64, - set_rows: u64, -} - -impl Emitter<'_> { - async fn binary( - &mut self, - client: &Client, - statement: &Statement, - rows: tokio_postgres::RowStream, - ) -> Result<(), DriverError> { - let mut rows = std::pin::pin!(rows); - let mut started = false; - while let Some(row) = rows.next().await { - let row = row.map_err(|error| map_error(&error))?; - if !started { - started = true; - let columns: Arc<[ResultColumn]> = row.columns().iter().map(result_column).collect(); - self.send(ResultEvent::ResultSetStarted { columns }).await?; - } - self.row(decode_row(&row)?).await?; - } - if !started { - // Still inside the read's transaction, so the columns of an - // empty result are read in it. - let columns: Arc<[ResultColumn]> = describe(client, statement).await?.into(); - self.send(ResultEvent::ResultSetStarted { columns }).await?; - } - self.finish().await - } - - async fn text(&mut self, messages: tokio_postgres::SimpleQueryStream) -> Result<(), DriverError> { - let mut messages = std::pin::pin!(messages); - let mut first_error = None; - while let Some(message) = messages.next().await { - match message { - Ok(SimpleQueryMessage::RowDescription(columns)) => { - let columns = columns.iter().map(|column| text_column(column.name())).collect(); - self.send(ResultEvent::ResultSetStarted { columns }).await?; - } - Ok(SimpleQueryMessage::Row(row)) => { - let values = (0..row.len()) - .map(|index| row.get(index).map_or(Value::Null, |text| Value::Text(text.to_owned()))) - .collect(); - self.row(values).await?; - } - Ok(SimpleQueryMessage::CommandComplete(_)) => self.finish().await?, - Ok(_) => {} - Err(error) if error.as_db_error().is_none() => return Err(map_error(&error)), - Err(error) => { - first_error.get_or_insert_with(|| map_error(&error)); - } - } - } - first_error.map_or(Ok(()), Err) - } - - async fn row(&mut self, values: Vec) -> Result<(), DriverError> { - self.batch.push(values); - self.rows += 1; - self.set_rows += 1; - if self.batch.len() >= BATCH_ROWS { - self.flush().await?; +async fn binary( + emitter: &mut ReadEmitter<'_>, + client: &Client, + statement: &Statement, + rows: tokio_postgres::RowStream, +) -> Result<(), DriverError> { + let mut rows = std::pin::pin!(rows); + while let Some(row) = rows.next().await { + let row = row.map_err(|error| map_error(&error))?; + if !emitter.is_open() { + let columns: Arc<[ResultColumn]> = row.columns().iter().map(result_column).collect(); + emitter.start(columns).await?; } - Ok(()) + emitter.row(decode_row(&row)?).await?; } - - async fn flush(&mut self) -> Result<(), DriverError> { - if self.batch.is_empty() { - return Ok(()); - } - let rows = std::mem::take(&mut self.batch); - self.send(ResultEvent::Rows(rows)).await - } - - async fn finish(&mut self) -> Result<(), DriverError> { - self.flush().await?; - let rows = std::mem::take(&mut self.set_rows); - self.send(ResultEvent::ResultSetFinished { - retained: rows, - total_rows: Some(rows), - truncation: Truncation::Complete, - }) - .await + if !emitter.is_open() { + // Still inside the read's transaction, so the columns of an + // empty result are read in it. + let columns: Arc<[ResultColumn]> = describe(client, statement).await?.into(); + emitter.start(columns).await?; } + emitter.finish().await +} - /// A consumer that went away ends the read: the rows would go - /// nowhere. - async fn send(&mut self, event: ResultEvent) -> Result<(), DriverError> { - match self.sink.accept(event).await { - SinkFlow::Continue => Ok(()), - SinkFlow::ConsumerGone => Err(DriverError::Cancelled), +async fn text(emitter: &mut ReadEmitter<'_>, messages: tokio_postgres::SimpleQueryStream) -> Result<(), DriverError> { + let mut messages = std::pin::pin!(messages); + let mut first_error = None; + while let Some(message) = messages.next().await { + match message { + Ok(SimpleQueryMessage::RowDescription(columns)) => { + let columns = columns.iter().map(|column| text_column(column.name())).collect(); + emitter.start(columns).await?; + } + Ok(SimpleQueryMessage::Row(row)) => { + let values = (0..row.len()) + .map(|index| row.get(index).map_or(Value::Null, |text| Value::Text(text.to_owned()))) + .collect(); + emitter.row(values).await?; + } + Ok(SimpleQueryMessage::CommandComplete(_)) => emitter.finish().await?, + Ok(_) => {} + Err(error) if error.as_db_error().is_none() => return Err(map_error(&error)), + Err(error) => { + first_error.get_or_insert_with(|| map_error(&error)); + } } } + first_error.map_or(Ok(()), Err) } #[cfg(test)] diff --git a/core/crates/drivers/redis/src/editor_run.rs b/core/crates/drivers/redis/src/editor_run.rs index 596b7b941c..147190b5d8 100644 --- a/core/crates/drivers/redis/src/editor_run.rs +++ b/core/crates/drivers/redis/src/editor_run.rs @@ -6,7 +6,7 @@ use tablepro_core::sql_syntax::StatementAccess; use tablepro_core::sql_syntax::redis::{EditorUse, command_access, editor_use, split_commands}; use tablepro_core::{ DriverError, ReadOnlyRefusal, ResultSink, RunEnd, RunOptions, RunSummary, SinkFlow, TransactionState, - UnsupportedFeature, UserSql, + UnsupportedFeature, UserSql, deadline_elapsed, }; use tokio::time::Instant; use tokio_util::sync::CancellationToken; @@ -171,7 +171,7 @@ impl EditorRun { flow = emit(sink, shape, Some(options.row_limit)) => Ok(flow), () = options.cancel.cancelled() => Err(Interrupt::Cancelled), () = self.shutdown.cancelled() => Err(Interrupt::Cancelled), - () = until(deadline) => Err(Interrupt::DeadlineElapsed), + () = deadline_elapsed(deadline) => Err(Interrupt::DeadlineElapsed), } } @@ -191,7 +191,7 @@ impl EditorRun { }, () = cancel.cancelled() => Interrupt::Cancelled, () = self.shutdown.cancelled() => Interrupt::Cancelled, - () = until(deadline) => Interrupt::DeadlineElapsed, + () = deadline_elapsed(deadline) => Interrupt::DeadlineElapsed, }; let grace_ends = Instant::now() + self.endpoint.liveness().cancel_grace; let control = tokio::time::timeout_at(grace_ends, self.endpoint.open()) @@ -296,13 +296,6 @@ fn is_unblocked_reply(error: &redis::ServerError) -> bool { is_unblocked(&crate::errors::server_error(error)) } -async fn until(deadline: Option) { - match deadline { - Some(deadline) => tokio::time::sleep_until(deadline).await, - None => std::future::pending().await, - } -} - #[cfg(test)] mod tests { use super::*; diff --git a/core/crates/drivers/redis/src/editor_session.rs b/core/crates/drivers/redis/src/editor_session.rs index 70419d58e2..68676e395c 100644 --- a/core/crates/drivers/redis/src/editor_session.rs +++ b/core/crates/drivers/redis/src/editor_session.rs @@ -3,15 +3,14 @@ use std::time::Duration; use async_trait::async_trait; use tablepro_core::{ - CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState, LossPhase, - ResultSink, RunOptions, RunSummary, TransactionState, UserSql, + CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState, + EditorSessionStatus, LossPhase, ResultSink, RunOptions, RunSummary, TransactionState, UserSql, }; use tokio_util::sync::CancellationToken; use crate::editor_run::EditorRun; use crate::endpoint::RedisEndpoint; use crate::link::Link; -use crate::session_status::SessionStatus; /// One editor tab's own link to the server. /// @@ -22,7 +21,7 @@ pub(crate) struct RedisEditorSession { id: EditorSessionId, endpoint: Arc, link: Arc>>, - status: Arc, + status: Arc, transaction: Arc>, read_only: bool, statement_timeout: Option, @@ -44,7 +43,7 @@ impl RedisEditorSession { id: EditorSessionId::new(), endpoint, link: Arc::new(Mutex::new(Some(link))), - status: Arc::new(SessionStatus::new()), + status: Arc::new(EditorSessionStatus::new()), transaction: Arc::new(Mutex::new(TransactionState::Idle)), read_only, statement_timeout: options.statement_timeout, diff --git a/core/crates/drivers/redis/src/lib.rs b/core/crates/drivers/redis/src/lib.rs index 876fb2d3a2..c97e6de642 100644 --- a/core/crates/drivers/redis/src/lib.rs +++ b/core/crates/drivers/redis/src/lib.rs @@ -21,7 +21,6 @@ mod key_scan; mod link; mod reply_rows; mod server_version; -mod session_status; mod stream_read; mod tls_watch; mod workspace_link; diff --git a/core/crates/drivers/redis/src/reply_rows.rs b/core/crates/drivers/redis/src/reply_rows.rs index cfe8e14b63..8ec783661a 100644 --- a/core/crates/drivers/redis/src/reply_rows.rs +++ b/core/crates/drivers/redis/src/reply_rows.rs @@ -5,7 +5,7 @@ use tablepro_core::column::{ ColumnKind, ColumnType, FloatWidth, IntegerKind, IntegerWidth, ReadForm, ResultColumn, TextLength, }; use tablepro_core::value::{JsonText, Value}; -use tablepro_core::{DriverError, ResultEvent, ResultSink, RowLimit, SinkFlow, Truncation}; +use tablepro_core::{DriverError, ResultEvent, ResultSink, RowBatch, RowLimit, SinkFlow, Truncation}; use crate::errors::server_error; use crate::key_name::quoted_argument; @@ -111,10 +111,6 @@ fn json(reply: &Reply) -> serde_json::Value { } } -/// Rows per `ResultEvent::Rows`. The sink is awaited per batch, so a -/// slow grid slows the run instead of growing a queue. -const BATCH_ROWS: usize = 256; - /// Stream one reply into `sink`, keeping at most `limit` rows of a table. /// The reply is already whole in memory, so the rows past the limit are /// counted and dropped. @@ -131,7 +127,7 @@ pub(crate) async fn emit(sink: &mut dyn ResultSink, shape: ReplyShape, limit: Op } let mut rows = rows.into_iter().peekable(); while rows.peek().is_some() { - let batch: Vec<_> = rows.by_ref().take(BATCH_ROWS).collect(); + let batch: Vec<_> = rows.by_ref().take(RowBatch::MAX_ROWS).collect(); if sink.accept(ResultEvent::Rows(batch)).await == SinkFlow::ConsumerGone { return SinkFlow::ConsumerGone; } diff --git a/core/crates/drivers/redis/src/session_status.rs b/core/crates/drivers/redis/src/session_status.rs deleted file mode 100644 index 2274866015..0000000000 --- a/core/crates/drivers/redis/src/session_status.rs +++ /dev/null @@ -1,74 +0,0 @@ -use std::sync::atomic::{AtomicU8, Ordering}; - -use tablepro_core::{DriverError, EditorSessionState, LossPhase}; - -const READY: u8 = 0; -const RUNNING: u8 = 1; -const LOST: u8 = 2; - -/// What an editor session handle answers without waiting for a run. -#[derive(Debug)] -pub(crate) struct SessionStatus { - state: AtomicU8, -} - -impl SessionStatus { - pub(crate) fn new() -> Self { - Self { - state: AtomicU8::new(READY), - } - } - - pub(crate) fn state(&self) -> EditorSessionState { - match self.state.load(Ordering::SeqCst) { - READY => EditorSessionState::Ready, - RUNNING => EditorSessionState::Running, - _ => EditorSessionState::Lost, - } - } - - /// Claim the session for one run: a reply read for one run must not - /// be taken by another on the same link. - pub(crate) fn begin(&self) -> Result<(), DriverError> { - match self - .state - .compare_exchange(READY, RUNNING, Ordering::SeqCst, Ordering::SeqCst) - { - Ok(_) => Ok(()), - Err(RUNNING) => Err(DriverError::EditorSessionBusy), - Err(_) => Err(DriverError::ConnectionLost { - during: LossPhase::Idle, - }), - } - } - - pub(crate) fn finish(&self) { - let _ = self - .state - .compare_exchange(RUNNING, READY, Ordering::SeqCst, Ordering::SeqCst); - } - - pub(crate) fn lose(&self) { - self.state.store(LOST, Ordering::SeqCst); - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn a_second_run_is_busy_and_a_lost_session_refuses_runs() { - let status = SessionStatus::new(); - assert!(status.begin().is_ok()); - assert_eq!(status.begin(), Err(DriverError::EditorSessionBusy)); - - status.finish(); - assert_eq!(status.state(), EditorSessionState::Ready); - - status.lose(); - assert!(matches!(status.begin(), Err(DriverError::ConnectionLost { .. }))); - status.finish(); - assert_eq!(status.state(), EditorSessionState::Lost); - } -} diff --git a/core/crates/drivers/sqlite/src/connection.rs b/core/crates/drivers/sqlite/src/connection.rs index 2ae404648a..689e27596c 100644 --- a/core/crates/drivers/sqlite/src/connection.rs +++ b/core/crates/drivers/sqlite/src/connection.rs @@ -17,7 +17,7 @@ use tablepro_core::{ CallOptions, ColumnInfo, CommitResolution, CommitToken, Connection, DriverError, EditorSession, EditorSessionOptions, FileEndpoint, FileOpenMode, ForeignKeyInfo, LinkState, LinkWatch, LivenessPolicy, LossPhase, OwnedCalls, QueryResult, ReadOnlyRefusal, ReadStatement, ResultSink, RowLimit, ServerInfo, StreamSummary, - TimeoutPhase, WorkspaceSettings, WriteAtomicity, WriteBatch, WriteKind, WriteLedger, WriteReport, + TimeoutPhase, WorkspaceSettings, WriteAtomicity, WriteBatch, WriteKind, WriteLedger, WriteReport, deadline_elapsed, }; use tokio::time::Instant; use tokio_util::sync::{CancellationToken, WaitForCancellationFutureOwned}; @@ -159,7 +159,7 @@ impl SqliteConnection { tokio::select! { biased; () = options.cancel().cancelled() => Err(DriverError::Cancelled), - () = deadline::elapsed(options.deadline()) => Err(DriverError::Timeout { + () = deadline_elapsed(options.deadline()) => Err(DriverError::Timeout { phase: TimeoutPhase::Statement, server_cancelled: false, }), @@ -232,7 +232,7 @@ impl SqliteConnection { tokio::select! { biased; () = options.cancel().cancelled() => Err(DriverError::Cancelled), - () = deadline::elapsed(options.deadline()) => Err(DriverError::Timeout { + () = deadline_elapsed(options.deadline()) => Err(DriverError::Timeout { phase: TimeoutPhase::Probe, server_cancelled: false, }), @@ -245,7 +245,7 @@ impl SqliteConnection { tokio::select! { biased; () = options.cancel().cancelled() => Err(DriverError::Cancelled), - () = deadline::elapsed(options.deadline()) => Err(DriverError::Timeout { + () = deadline_elapsed(options.deadline()) => Err(DriverError::Timeout { phase: TimeoutPhase::Statement, server_cancelled: false, }), diff --git a/core/crates/drivers/sqlite/src/deadline.rs b/core/crates/drivers/sqlite/src/deadline.rs index 95aaf0f12f..f57924dc14 100644 --- a/core/crates/drivers/sqlite/src/deadline.rs +++ b/core/crates/drivers/sqlite/src/deadline.rs @@ -1,13 +1,5 @@ use tokio::time::Instant; -/// Resolves when `deadline` passes, and never when there is none. -pub(crate) async fn elapsed(deadline: Option) { - match deadline { - Some(at) => tokio::time::sleep_until(at).await, - None => std::future::pending().await, - } -} - /// The earlier of two deadlines, where either may be absent. pub(crate) fn earliest(first: Option, second: Option) -> Option { match (first, second) { diff --git a/core/crates/drivers/sqlite/src/editor_session.rs b/core/crates/drivers/sqlite/src/editor_session.rs index e5886f7d5d..439ea06058 100644 --- a/core/crates/drivers/sqlite/src/editor_session.rs +++ b/core/crates/drivers/sqlite/src/editor_session.rs @@ -8,14 +8,13 @@ use sqlx::Connection as _; use sqlx::sqlite::{SqliteConnectOptions, SqliteConnection as SqlxConnection}; use tablepro_core::{ CallOptions, DriverError, EditorSession, EditorSessionId, EditorSessionOptions, EditorSessionState, LivenessPolicy, - LossPhase, ResultSink, RunEnd, RunOptions, RunSummary, TimeoutPhase, TransactionState, UserSql, + LossPhase, ResultSink, RunEnd, RunOptions, RunSummary, TimeoutPhase, TransactionState, UserSql, deadline_elapsed, }; use tokio::sync::OwnedMutexGuard; use tokio::time::Instant; use tokio_util::sync::CancellationToken; use crate::autocommit::is_autocommit; -use crate::deadline; use crate::errors::{map_error, map_open_error}; use crate::interrupt::InterruptFlag; use crate::result_stream::{StreamOutcome, run_script}; @@ -191,7 +190,7 @@ impl Shared { }; } () = options.cancel.cancelled() => Stop::Cancelled, - () = deadline::elapsed(deadline) => Stop::DeadlineElapsed, + () = deadline_elapsed(deadline) => Stop::DeadlineElapsed, }; flag.raise(); let settled = tokio::time::timeout(self.cancel_grace, &mut running).await; @@ -311,7 +310,7 @@ impl EditorSession for SqliteEditorSession { let mut held = tokio::select! { biased; () = options.cancel().cancelled() => return Err(DriverError::Cancelled), - () = deadline::elapsed(options.deadline()) => { + () = deadline_elapsed(options.deadline()) => { return Err(DriverError::Timeout { phase: TimeoutPhase::Statement, server_cancelled: false }); } held = shared.connection.lock() => held, diff --git a/core/crates/session/src/health/health_monitor.rs b/core/crates/session/src/health/health_monitor.rs index a1e41a0239..ac04c6d7b0 100644 --- a/core/crates/session/src/health/health_monitor.rs +++ b/core/crates/session/src/health/health_monitor.rs @@ -1,7 +1,7 @@ use std::sync::{Arc, Mutex, PoisonError}; use std::time::Duration; -use tablepro_core::CallOptions; +use tablepro_core::{CallOptions, deadline_elapsed}; use tablepro_storage::CredentialDemand; use tokio::sync::watch; use tokio::time::Instant; @@ -60,7 +60,7 @@ pub(crate) async fn run_monitor(ctx: MonitorContext) { biased; () = ctx.cancel.cancelled() => return, signals = ctx.mailbox.next() => Wakeup::Signals(signals), - () = sleep_until(policy.next_deadline()) => Wakeup::Deadline, + () = deadline_elapsed(policy.next_deadline()) => Wakeup::Deadline, generation = lease_lost(watched) => after_loss(&ctx.mailbox, generation), }; let now = Instant::now(); @@ -111,13 +111,6 @@ fn after_loss(mailbox: &MonitorMailbox, generation: LinkGeneration) -> Wakeup { } } -async fn sleep_until(deadline: Option) { - match deadline { - Some(deadline) => tokio::time::sleep_until(deadline).await, - None => std::future::pending().await, - } -} - /// Resolves when the leased connection reports itself lost, or when the /// SSH master under it exits. async fn lease_lost(lease: Option) -> LinkGeneration { From 75ddee39608e04d5e39ca8d1fa69f61a45425c21 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 18 Nov 2026 07:05:36 +0700 Subject: [PATCH 2/2] docs(changelog): name the empty AI reply fix --- apple/changelog.d/4317.fixed.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 apple/changelog.d/4317.fixed.md diff --git a/apple/changelog.d/4317.fixed.md b/apple/changelog.d/4317.fixed.md new file mode 100644 index 0000000000..63e897ed9b --- /dev/null +++ b/apple/changelog.d/4317.fixed.md @@ -0,0 +1 @@ +A Claude, Gemini, OpenAI or xAI reply that ended with nothing in it showed an empty message instead of an error.