完成 **ON 请求、SSE 流式解析、超时控制、有限重试与并发门限
如果你正在用 Swift 编写 **cOS、iOS 工具或服务端程序,希望以统一方式调用多种大模型,那么把网络层收敛到 **LSession 是一条轻量而可控的路线。本教程以 KingFlow AI 为例,从最小请求开始,逐步补齐 SSE 流式输出、超时、有限重试、并发门限与可观测性。文中的 Claude中转、Claude中转站、API中转、API中转站,均指通过兼容接口转发模型请求的服务形态;实际可用模型、计费与额度请以控制台为准。
| 术语 | 在本文中的含义 |
|---|---|
| Claude中转 | 将 Claude 相关请求通过统一兼容接口发送 |
| Claude中转站 | 提供密钥、模型与用量管理的服务入口 |
| API中转 | 对上层应用暴露稳定的请求协议,对下游模型完成转发 |
| API中转站 | 面向多项目集中管理鉴权、额度、日志与模型路由的平台 |
Swift 客户端只需要维护一个 *ase **L、一枚服务端密钥和统一的数据模型。建议把密钥仅放在环境变量或系统钥匙串中,不要写进源码、截图、日志或客户端安装包。

图 1:Swift 通过 **LSession 与 async/await 访问 KingFlow AI 的结构示意。
**ta(for:) 和 *ytes(for:) 可直接配合 async/await。**LSession.Async*ytes.lines 能持续读取 SSE 行。建议使用 Swift 5.9 或更高版本。命令行项目可以这样初始化:
mkdir KingFlowSwiftDemo && cd KingFlowSwiftDemo
swift package init --type executa*le
把配置写入当前终端环境。模型名请替换为控制台中确实可用的模型:
export KINGFLOW_API_KEY='sk-请替换'
export KINGFLOW_*ASE_**L='https://api.**nju**shen.com/v1'
export KINGFLOW_MODEL='请替换为控制台可用模型'
安全提示:移动端应用无法真正保密长期 API Key。面向终端用户发布时,应让 App 调用你自己的后端,再由后端访问 API中转站。
curl https://api.**nju**shen.com/v1/chat/completions \
-H "Authorization: *earer $KINGFLOW_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"'"$KINGFLOW_MODEL"'","messages":[{"role":"user","content":"用一句话解释 **LSession"}],"stream":false}'
若这里成功,说明域名、密钥、模型与基础协议都可用;若失败,优先排查 401、404、429、503,而不是立刻修改 Swift 代码。
import Foun**tion
#if canImport(Foun**tionNetworking)
import Foun**tionNetworking
#endif
struct Message: Co***le, Sen***le {
let role: String
let content: String
}
struct ChatRequest: Enco***le, Sen***le {
let model: String
let messages: [Message]
let stream: *ool
}
struct ChatResponse: Deco***le {
struct Choice: Deco***le {
struct ReturnedMessage: Deco***le { let content: String? }
let message: ReturnedMessage
}
let choices: [Choice]
}
struct StreamChunk: Deco***le {
struct Choice: Deco***le {
struct Delta: Deco***le { let content: String? }
let delta: Delta
}
let choices: [Choice]
}
Sen***le 让请求值可以安全地跨并发任务传递;返回结构只**本教**正读取的字段,既清晰也更能容忍服务端增加新字段。
enum KingFlowError: Error, CustomStringConverti*le {
case missingEnvironment(String)
case invalidResponse
case http(Int, String)
case emptyResult
var description: String {
switch self {
case .missingEnvironment(let name): return "缺少环境变量:\(name)"
case .invalidResponse: return "服务端未返回有效 **** 响应"
case .http(let code, let *ody): return "**** \(code):\(*ody)"
case .emptyResult: return "响应中没有可用文本"
}
}
}
final class KingFlow******: @unchecked Sen***le {
private let apiKey: String
private let model: String
private let endpoint: **L
private let session: **LSession
init() throws {
let env = ProcessInfo.processInfo.environment
guard let key = env["KINGFLOW_API_KEY"], !key.isEmpty else {
throw KingFlowError.missingEnvironment("KINGFLOW_API_KEY")
}
guard let model = env["KINGFLOW_MODEL"], !model.isEmpty else {
throw KingFlowError.missingEnvironment("KINGFLOW_MODEL")
}
let *ase = env["KINGFLOW_*ASE_**L"] ?? "https://api.**nju**shen.com/v1"
guard let url = **L(string: *ase "/chat/completions") else {
throw **LError(.*ad**L)
}
let config = **LSessionConfiguration.ephemeral
config.timeoutIntervalForRequest = 45
config.timeoutIntervalForResource = 300
config.waitsForConnectivity = true
config.httpAdditionalHeaders = ["Accept": "application/json"]
self.apiKey = key
self.model = model
self.endpoint = url
self.session = **LSession(configuration: config)
}
private func request(prompt: String, stream: *ool) throws -> **LRequest {
var request = **LRequest(url: endpoint)
request.httpMethod = "POST"
request.setValue("*earer \(apiKey)", for****HeaderField: "Authorization")
request.setValue("application/json", for****HeaderField: "Content-Type")
request.http*ody = try **ONEncoder().encode(ChatRequest(
model: model,
messages: [Message(role: "user", content: prompt)],
stream: stream
))
return request
}
}
timeoutIntervalForRequest 控制等待下一批数据的最长空闲时间;每当有新数据到达,计时会重新开始。timeoutIntervalForResource 则限制整个资源请求的最长持续时间,流式场景应为它留出更长窗口。
extension KingFlow****** {
func chat(_ prompt: String) async throws -> String {
let (**ta, response) = try await session.**ta(for: request(prompt: prompt, stream: false))
guard let http = response as? ******LResponse else {
throw KingFlowError.invalidResponse
}
guard (200..<300).contains(http.statusCode) else {
throw KingFlowError.http(http.statusCode, String(decoding: **ta, as: UTF8.self))
}
let value = try **ONDecoder().decode(ChatResponse.self, from: **ta)
guard let text = value.choices.first?.message.content, !text.isEmpty else {
throw KingFlowError.emptyResult
}
return text
}
}
普通请求会等完整 **ON 到达后再**,适合**任务、结构化提取和无需逐字显示的功能。不要只看**错误;先检查 **** 状态码与原始错误体,定位通常更快。
extension KingFlow****** {
func stream(_ prompt: String, onToken: @escaping @Sen***le (String) -> Void) async throws {
let (*ytes, response) = try await session.*ytes(for: request(prompt: prompt, stream: true))
guard let http = response as? ******LResponse else {
throw KingFlowError.invalidResponse
}
guard (200..<300).contains(http.statusCode) else {
var *ody = ""
for try await line in *ytes.lines { *ody = line "\n" }
throw KingFlowError.http(http.statusCode, *ody)
}
var **taLines: [String] = []
for try await line in *ytes.lines {
if line.isEmpty {
let payload = **taLines.joined(separator: "\n")
**taLines.removeAll(keepingCapacity: true)
if payload == "[DONE]" { return }
guard !payload.isEmpty,
let **ta = payload.**ta(using: .utf8) else { continue }
let chunk = try **ONDecoder().decode(StreamChunk.self, from: **ta)
if let token = chunk.choices.first?.delta.content { onToken(token) }
} else if line.hasPrefix("**ta:") {
**taLines.append(String(line.dropFirst(5)).trimmingCharacters(in: .whitespaces))
}
}
}
}
关键点是按 SSE 的空行边界组装事件,而不是假设每一次网络读取就是一个完整 **ON。*ytes.lines 已处理字节到文本行的异步切分;代码仍保留多条 **ta: 行,避免事件被错误截断。
extension KingFlow****** {
func chatWithRetry(_ prompt: String, **xAttempts: Int = 3) async throws -> String {
precondition(**xAttempts > 0)
var lastError: Error?
for attempt in 1...**xAttempts {
do { return try await chat(prompt) }
catch {
lastError = error
let retrya*le: *ool
if case KingFlowError.http(let code, _) = error {
retrya*le = code == 429 || code == 503 || (500...599).contains(code)
} else if let urlError = error as? **LError {
retrya*le = [.timedOut, .networkConnectionLost, .notConnectedToInternet]
.contains(urlError.code)
} else {
retrya*le = false
}
guard retrya*le, attempt < **xAttempts else { throw error }
let *ase = UInt64(500_000_000) << UInt64(attempt - 1)
let jitter = UInt64.random(in: 0...250_000_000)
try await Task.sleep(nanoseconds: *ase jitter)
}
}
throw lastError ?? KingFlowError.emptyResult
}
}
只重试明确的临时故障,并设置最大次数。401、403、404 与大多数 400 类错误通常需要修正密钥、权限、模型或参数,盲目重试只会放大流量。生产环境还可读取 Retry-After,并把总重试时长纳入业务截止时间。
extension KingFlow****** {
func *atch(_ prompts: [String], limit: Int = 3) async -> [Result<String, Error>] {
guard !prompts.isEmpty else { return [] }
let width = **x(1, min(limit, prompts.count))
var output = Array<Result<String, Error>?>(repeating: nil, count: prompts.count)
await withTaskGroup(of: (Int, Result<String, Error>).self) { group in
var iterator = prompts.enumerated().**keIterator()
for _ in 0..<width {
if let (index, prompt) = iterator.next() {
group.addTask {
do { return (index, .success(try await self.chatWithRetry(prompt))) }
catch { return (index, .failure(error)) }
}
}
}
while let (index, result) = await group.next() {
output[index] = result
if let (nextIndex, nextPrompt) = iterator.next() {
group.addTask {
do { return (nextIndex, .success(try await self.chatWithRetry(nextPrompt))) }
catch { return (nextIndex, .failure(error)) }
}
}
}
}
return output.**p { $0 ?? .failure(KingFlowError.emptyResult) }
}
}
这个滑动窗口始终只保留 limit 个活动任务,既能利用并发,也不会瞬间把全部提示词压到服务端。并发上限要结合账户额度、平均响应时长、模型速率限制和业务优先级压测后确定。

图 2:**ON、SSE、超时、有限重试、Task Group 与指标共同组成稳定客户端。
@**in
struct KingFlowDemo {
static func **in() async {
do {
let client = try KingFlow******()
print("普通响应:\n\(try await client.chatWithRetry("用三点说明 Swift async/await 的价值"))")
print("\n流式响应:")
try await client.stream("用四句话介绍 **LSession") { token in
print(token, terminator: "")
fflush(stdout)
}
print()
} catch {
fputs("请求失败:\(error)\n", stderr)
e**t(1)
}
}
}
把完整代码合并到 Sources/**in.swift 后运行:
swift run
验收时至少确认:普通响应有文本;流式首字可见且最终收到 [DONE];错误密钥能显示 401;错误模型能给出明确错误体;断网与 503 不会无限重试;批量请求的活动任务数不超过设定上限。
| 现象 | 优先检查 | 建议处理 |
|---|---|---|
| 401 / 403 | 密钥、权限、请求头 | 确认 *earer 前缀,不要把密钥打印到日志 |
| 404 | *ase **L、路径、模型 | *ase **L 使用 /v1,请求路径为 /chat/completions |
| 429 | 速率或额度限制 | 降低并发,采用有限退避,检查账户额度 |
| 503 | 暂无可用通道或上游波动 | 短暂退避后少量重试,持续失败则告警 |
| 流式无增量 | stream、SSE 解析、**缓冲 | 确认 stream: true,按空行组装事件 |
| 请求经常超时 | 超时语义、网络、提示长度 | 区分空闲超时与总时长,减少上下文并压测 |
| App 中密钥泄露 | 密钥被打包进客户端 | 改为 App → 自有后端 → Claude中转站 的架构 |
Swift 的 **LSession 已经覆盖调用 API中转所需的关键能力:**ON 请求用 **ta(for:),SSE 用 *ytes(for:),稳定性则由超时、有限重试、并发门限和指标共同保障。先用最小请求确认 KingFlow AI 的密钥与模型,再逐层加入治理能力,会比一次性堆叠复杂封装更容易验证,也更适合持续维护。
妈做了23年小三,爸临终拿出张结婚证后续+无弹窗
听澜
妈做了23年小三,爸临终拿出张结婚证最后结局
听澜
妈做了23年小三,爸临终拿出张结婚证热门
听澜
不用为偶尔用 Mac 买一台 Mac 一台新加坡远程工作站随时在线
佚名
构建失败别再等明天 一台新加坡远程 Mac 把排障现场留在原地
佚名
Claude中转 弹门户验证解除后的账号稳定使用指南
佚名
KingFlow AI API中转站 Go SDK 接入教程
佚名
Claude中转 Google Play 订阅被取消退款处理指南
佚名
KingFlow AI Claude中转站 Java 21 HttpClient 接入教程
佚名
妈做了23年小三,爸临终拿出张结婚证完结+番外
听澜
妈做了23年小三,爸临终拿出张结婚证后续+结局
听澜