README
U
Prism
U
PrismEvent
U
PrismFinishReason
U
PrismOptions
U
PrismThinking
U
PrismToolCall
U
PrismToolResult

#src/lux — Lucent IR 核心包（导航索引）

MoonBit 目录 = 包：本目录是一个包，不能再建子文件夹（子文件夹 = 子包，会破坏 inherent methods 与包环约束，见 docs/report/lux-split-feasibility.md）。包内组织靠文件名前缀 + 职责分区，本文件为阅读导航。

#文件地图

#1. 类型与构造（先读这里）

文件	内容
types.mbt	全部 IR 类型定义（Lucent* struct/enum，含诊断 Conversion* 类型）
builders.mbt	构造器（LucentX::new/default/create + with_* 副本方法）
helpers.mbt	跨包辅助（lucent_* 提取函数、to_string/from_string 映射）
stream.mbt	流事件类型（LucentStreamEvent / BlockAccumulator）

#2. 序列化（IR → JSON）

文件	内容
serialize_meta.mbt	元数据序列化
serialize_primitives.mbt	基础类型 to_json
serialize_request.mbt	LucentRequest → JSON
serialize_response.mbt	LucentResponse → JSON
serialize_stream.mbt	流事件 → JSON
diagnostics_json.mbt	ConversionStatus/Diagnostic 的 JSON 编解码

#3. 反序列化（JSON → IR）

文件	内容
deserialize_helpers.mbt	get_/parse_ 共享辅助
deserialize_primitives.mbt	基础类型 from_json（Modality~AgentAction）
deserialize_content.mbt	Content/Message/ConversationItem
deserialize_tools.mbt	Tool/ToolChoice/StructuredOutput
deserialize_options.mbt	Options/ReasoningConfig/Capabilities
deserialize_request.mbt / deserialize_response.mbt / deserialize_stream.mbt	对应 to_json 的 from_json

#4. 测试

*_wbtest.mbt：白盒测试（留包内，MoonBit 约束）
test/：黑盒测试子包（public API 校验）

#依赖方向

types.mbt → builders/helpers → serialize_*/deserialize_*（单向； helpers 提供 to_string/from_string 给编解码复用）。

#约定

新增类型 → types.mbt；新增构造器 → builders.mbt；新增辅助 → helpers.mbt
序列化与反序列化成对修改（serialize_X ↔ deserialize_X 一一对应）
遵循 docs/rules/naming-conventions.md

AccumulatedResponse

source

pub struct AccumulatedResponse {
  response : LucentResponse
  annotations : Array[LucentAnnotation]
  native_events : Array[LucentStreamEvent]
  agent_actions : Array[LucentAgentAction]
  diagnostics : Array[ConversionDiagnostic]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

AccumulatedResponse — 累加器产物：response + 未进入 response 的辅助信息

AccumulatedResponse::equal

source

fn AccumulatedResponse::equal(AccumulatedResponse, AccumulatedResponse) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

BlockAccumulator

source

pub(all) struct BlockAccumulator {
  block_types : Array[LucentBlockType]
  block_texts : Array[StringBuilder]
  block_thinking : Array[StringBuilder]
  block_signatures : Array[StringBuilder]
  block_tool_ids : Array[String]
  block_tool_names : Array[String]
}

BlockAccumulator — 块状态跟踪器

管理流式解码中的块生命周期：按 block_index 跟踪类型、文本、 thinking、签名、工具调用信息。提供 ensure/flush/discard 操作。

BlockAccumulator::discard_block

source

fn BlockAccumulator::discard_block(self : BlockAccumulator, idx : Int) -> Unit

丢弃该块已累加内容（Gemini 全量帧覆盖语义），保留类型信息

BlockAccumulator::ensure_block

source

fn BlockAccumulator::ensure_block(self : BlockAccumulator, idx : Int) -> Unit

确保 block_index 在跟踪数组中占位

BlockAccumulator::flush_block

source

fn BlockAccumulator::flush_block(self : BlockAccumulator, idx : Int, content : Array[LucentContent], reasoning : LucentThinking?) -> LucentThinking?

按类型把已累加内容刷入 content 数组

BlockAccumulator::flush_remaining

source

fn BlockAccumulator::flush_remaining(self : BlockAccumulator, content : Array[LucentContent], reasoning : LucentThinking?) -> LucentThinking?

流结束时 flush 所有未闭合的块

BlockAccumulator::new

source

fn BlockAccumulator::new() -> BlockAccumulator

创建空的 BlockAccumulator

ConversationSnapshot

source

pub struct ConversationSnapshot {
  response_id : String
  request : LucentRequest
  response_text : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ConversationSnapshot — 中间件本地会话存储单元（T8）

背景：Responses 的 previous_response_id 是有状态续接——客户端第二轮只带新 input + 上一轮 response id，历史在服务端。跨端转到无状态端点（chat/messages/gemini）时必须由中间件本地保存并还原历史。本类型是存储单元：某次 response_id 对应的请求上下文（还原所需）与可选响应文本（审计/调试用）。不参与 wire 编解码； to_json/from_json 供宿主持久化（IR 提案见 .agent-workplace/docs/report/ir-proposal-previous-response-id.md）。

ConversationSnapshot::equal

source

fn ConversationSnapshot::equal(ConversationSnapshot, ConversationSnapshot) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

ConversationSnapshot::from_json

source

fn ConversationSnapshot::from_json(jv : Json) -> Result[ConversationSnapshot, String]

ConversationSnapshot 反序列化（T8；缺失字段软失败为 Err 由调用方处置）

ConversationSnapshot::new

source

fn ConversationSnapshot::new(response_id : String, request : LucentRequest, response_text : String?) -> ConversationSnapshot

ConversationSnapshot 构造器（T8）

ConversationSnapshot::to_json

source

fn ConversationSnapshot::to_json(self : ConversationSnapshot) -> Json

ConversationSnapshot 序列化（T8；宿主持久化用，不参与 wire）

ConversionDiagnostic

source

pub struct ConversionDiagnostic {
  field : String
  status : ConversionStatus
  detail : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ConversionDiagnostic — 单个字段的转换结果诊断

ConversionDiagnostic::degraded

source

fn ConversionDiagnostic::degraded(field : String, detail : String?) -> ConversionDiagnostic

构造 Degraded 诊断（provider 适配器共用样板）。

ConversionDiagnostic::equal

source

fn ConversionDiagnostic::equal(ConversionDiagnostic, ConversionDiagnostic) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

ConversionDiagnostic::from_json

source

fn ConversionDiagnostic::from_json(jv : Json) -> Result[ConversionDiagnostic, String]

ConversionDiagnostic::new

source

fn ConversionDiagnostic::new(field : String, status : ConversionStatus, detail : String?) -> ConversionDiagnostic

ConversionDiagnostic::status

source

fn ConversionDiagnostic::status(self : ConversionDiagnostic) -> ConversionStatus

获取诊断状态。

ConversionDiagnostic::to_json

source

fn ConversionDiagnostic::to_json(self : ConversionDiagnostic) -> Json

ConversionDiagnostic::unsupported

source

fn ConversionDiagnostic::unsupported(field : String, detail : String?) -> ConversionDiagnostic

构造 Unsupported 诊断（provider 适配器共用样板）。

ConversionResult

source

pub struct ConversionResult[T] {
  value : T
  diagnostics : Array[ConversionDiagnostic]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ConversionResult — 带诊断的转换结果成功时不等于 Exact：value 可用但部分字段已丢失

ConversionResult::diagnostics

source

fn[T] ConversionResult::diagnostics(self : ConversionResult[T]) -> Array[ConversionDiagnostic]

获取转换诊断列表。

ConversionResult::envelope_json

source

fn[T] ConversionResult::envelope_json(self : ConversionResult[T], value_json : Json) -> Json

信封 JSON：{"value":<value_json>,"diagnostics":[...]}（WASM/SDK 边界用）。

ConversionResult::equal

source

fn[T : Eq] ConversionResult::equal(ConversionResult[T], ConversionResult[T]) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

ConversionResult::from_json

source

fn[T] ConversionResult::from_json(jv : Json, decode : (Json) -> Result[T, String]) -> Result[ConversionResult[T], String]

反序列化：value 由调用方提供解码函数。

ConversionResult::new

source

fn[T] ConversionResult::new(value : T) -> ConversionResult[T]

ConversionResult::to_json

source

fn[T] ConversionResult::to_json(self : ConversionResult[T], encode : (T) -> Json) -> Json

序列化：value 由调用方提供编码函数，diagnostics 统一编码。

ConversionResult::value

source

fn[T] ConversionResult::value(self : ConversionResult[T]) -> T

获取转换结果值。

ConversionResult::with_diagnostic

source

fn[T] ConversionResult::with_diagnostic(self : ConversionResult[T], diagnostic : ConversionDiagnostic) -> ConversionResult[T]

追加一条转换诊断（返回新结果，不修改原结果的诊断数组）。

ConversionResult::with_diagnostics

source

fn[T] ConversionResult::with_diagnostics(self : ConversionResult[T], diagnostics : Array[ConversionDiagnostic]) -> ConversionResult[T]

批量附加诊断（返回新结果，等价于逐条 with_diagnostic）。

ConversionStatus

source

pub(all) enum ConversionStatus {
  Exact
  Degraded
  Unsupported
  Invalid
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ConversionStatus — 字段转换状态（五道门治理要求）

ConversionStatus::equal

source

fn ConversionStatus::equal(ConversionStatus, ConversionStatus) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

ConversionStatus::from_json

source

fn ConversionStatus::from_json(jv : Json) -> Result[ConversionStatus, String]

ConversionStatus::to_json

source

fn ConversionStatus::to_json(self : ConversionStatus) -> Json

LucentAgentAction

source

pub struct LucentAgentAction {
  kind : String
  id : String
  call_id : String?
  name : String?
  arguments_json : String?
  result : String?
  provider_payload : Json?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentAgentAction — Agent 动作占位（v1 仅类型化，参数走 provider_payload）

LucentAgentAction::equal

source

fn LucentAgentAction::equal(LucentAgentAction, LucentAgentAction) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentAgentAction::from_json

source

fn LucentAgentAction::from_json(jv : Json) -> Result[LucentAgentAction, String]

=== LucentAgentAction ===

LucentAgentAction::new

source

fn LucentAgentAction::new(kind : String, id : String, call_id : String?, name : String?, arguments_json : String?, result : String?, provider_payload : Json?) -> LucentAgentAction

LucentAgentAction::to_json

source

fn LucentAgentAction::to_json(self : LucentAgentAction) -> Json

LucentAnnotation

source

pub struct LucentAnnotation {
  kind : LucentAnnotationKind
  text : String?
  reference : String?
  start : Int?
  end : Int?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentAnnotation — 标注侧信道

LucentAnnotation::equal

source

fn LucentAnnotation::equal(LucentAnnotation, LucentAnnotation) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentAnnotation::from_json

source

fn LucentAnnotation::from_json(jv : Json) -> Result[LucentAnnotation, String]

=== LucentAnnotation ===

LucentAnnotation::new

source

fn LucentAnnotation::new(kind : LucentAnnotationKind, text : String?, reference : String?, start : Int?, end : Int?) -> LucentAnnotation

LucentAnnotation::to_json

source

fn LucentAnnotation::to_json(self : LucentAnnotation) -> Json

LucentAnnotationKind

source

pub(all) enum LucentAnnotationKind {
  Url
  FileCitation
  WebSearchCitation
  Native(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentAnnotationKind — 标注类型

LucentAnnotationKind::equal

source

fn LucentAnnotationKind::equal(LucentAnnotationKind, LucentAnnotationKind) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentAnnotationKind::from_json

source

fn LucentAnnotationKind::from_json(jv : Json) -> Result[LucentAnnotationKind, String]

=== LucentAnnotationKind ===

LucentAnnotationKind::to_json

source

fn LucentAnnotationKind::to_json(self : LucentAnnotationKind) -> String

LucentBlockDelta

source

pub(all) enum LucentBlockDelta {
  TextDelta(String)
  ThinkingDelta(String)
  SignatureDelta(String)
  ToolArgumentsDelta(String)
  RefusalDelta(String)
  NativeDelta(String, Json)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentBlockDelta — 块增量（类型化）

LucentBlockDelta::equal

source

fn LucentBlockDelta::equal(LucentBlockDelta, LucentBlockDelta) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentBlockDelta::from_json

source

fn LucentBlockDelta::from_json(jv : Json) -> Result[LucentBlockDelta, String]

=== LucentBlockDelta ===

LucentBlockDelta::native_delta

source

fn LucentBlockDelta::native_delta(tag : String, raw : Json) -> LucentBlockDelta

LucentBlockDelta::refusal_delta

source

fn LucentBlockDelta::refusal_delta(s : String) -> LucentBlockDelta

LucentBlockDelta::signature_delta

source

fn LucentBlockDelta::signature_delta(s : String) -> LucentBlockDelta

LucentBlockDelta::text_delta

source

fn LucentBlockDelta::text_delta(s : String) -> LucentBlockDelta

LucentBlockDelta::thinking_delta

source

fn LucentBlockDelta::thinking_delta(s : String) -> LucentBlockDelta

LucentBlockDelta::to_json

source

fn LucentBlockDelta::to_json(self : LucentBlockDelta) -> Json

LucentBlockDelta::tool_arguments_delta

source

fn LucentBlockDelta::tool_arguments_delta(s : String) -> LucentBlockDelta

LucentBlockType

source

pub(all) enum LucentBlockType {
  Text
  ToolCall(String, String)
  Thinking
  Refusal
  Image
  Audio
  Video
  Native(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentBlockType — 块类型（类型化，替代字符串）

LucentBlockType::equal

source

fn LucentBlockType::equal(LucentBlockType, LucentBlockType) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentBlockType::from_json

source

fn LucentBlockType::from_json(jv : Json) -> Result[LucentBlockType, String]

=== LucentBlockType ===

LucentBlockType::native

source

fn LucentBlockType::native(tag : String) -> LucentBlockType

LucentBlockType::refusal

source

fn LucentBlockType::refusal() -> LucentBlockType

LucentBlockType::text

source

fn LucentBlockType::text() -> LucentBlockType

LucentBlockType::thinking

source

fn LucentBlockType::thinking() -> LucentBlockType

LucentBlockType::to_json

source

fn LucentBlockType::to_json(self : LucentBlockType) -> Json

LucentStreamEvent JSON 序列化

LucentBlockType::tool_call

source

fn LucentBlockType::tool_call(id : String, name : String) -> LucentBlockType

LucentCapabilities

source

pub struct LucentCapabilities {
  tool_calling : SupportLevel
  parallel_tool_calls : SupportLevel
  reasoning : SupportLevel
  multimodal_input : SupportLevel
  structured_output : SupportLevel
  input_modalities : Array[LucentModality]
  output_modalities : Array[LucentModality]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentCapabilities — 标准化能力声明

LucentCapabilities::create

source

fn LucentCapabilities::create(tool_calling : SupportLevel, parallel_tool_calls : SupportLevel, reasoning : SupportLevel, multimodal_input : SupportLevel, structured_output : SupportLevel, input_modalities : Array[LucentModality], output_modalities : Array[LucentModality]) -> LucentCapabilities

LucentCapabilities::default

source

fn LucentCapabilities::default() -> LucentCapabilities

LucentCapabilities::equal

source

fn LucentCapabilities::equal(LucentCapabilities, LucentCapabilities) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentCapabilities::from_json

source

fn LucentCapabilities::from_json(jv : Json) -> Result[LucentCapabilities, String]

=== LucentCapabilities ===

LucentCapabilities::to_json

source

fn LucentCapabilities::to_json(self : LucentCapabilities) -> Json

LucentChoice

source

pub struct LucentChoice {
  index : Int
  message : LucentMessage
  finish_reason : LucentFinishReason
  safety_ratings : Array[LucentSafetyRating]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentChoice — 候选回复

LucentChoice::equal

source

fn LucentChoice::equal(LucentChoice, LucentChoice) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentChoice::from_json

source

fn LucentChoice::from_json(jv : Json) -> Result[LucentChoice, String]

=== LucentChoice ===

LucentChoice::new

source

fn LucentChoice::new(index : Int, message : LucentMessage, finish_reason : LucentFinishReason, safety_ratings : Array[LucentSafetyRating]?) -> LucentChoice

LucentChoice::to_json

source

fn LucentChoice::to_json(self : LucentChoice) -> Json

LucentContent

source

pub(all) enum LucentContent {
  Text(String, Array[LucentAnnotation]?)
  ToolUse(LucentToolUse)
  ToolResult(LucentToolResult)
  Thinking(LucentThinking)
  Refusal(String)
  Image(LucentMultimedia)
  Audio(LucentMultimedia)
  Video(LucentMultimedia)
  File(LucentMultimedia)
  Native(String, Json)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentContent — 内容块主枚举

LucentContent::audio

source

fn LucentContent::audio(media_type : String, source : LucentMediaSource) -> LucentContent

LucentContent::equal

source

fn LucentContent::equal(LucentContent, LucentContent) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentContent::file

source

fn LucentContent::file(media_type : String, source : LucentMediaSource) -> LucentContent

构造文件 content（PDF 等非媒体文件），来源三选一：url / inline / file_uri

LucentContent::from_json

source

fn LucentContent::from_json(jv : Json) -> Result[LucentContent, String]

=== LucentContent ===

LucentContent::image

source

fn LucentContent::image(media_type : String, source : LucentMediaSource) -> LucentContent

LucentContent::native

source

fn LucentContent::native(type_tag : String, raw : Json) -> LucentContent

LucentContent::redacted_thinking

source

fn LucentContent::redacted_thinking(signature : String?) -> LucentContent

LucentContent::refusal

source

fn LucentContent::refusal(text : String) -> LucentContent

LucentContent::text

source

fn LucentContent::text(s : String) -> LucentContent

LucentContent::text_with_annotations

source

fn LucentContent::text_with_annotations(s : String, annotations : Array[LucentAnnotation]) -> LucentContent

LucentContent::thinking

source

fn LucentContent::thinking(text : String, signature : String?) -> LucentContent

LucentContent::to_json

source

fn LucentContent::to_json(self : LucentContent) -> Json

LucentContent::tool_result

source

fn LucentContent::tool_result(tool_use_id : String, content : Array[LucentContent]) -> LucentContent

LucentContent::tool_result_error

source

fn LucentContent::tool_result_error(tool_use_id : String, content : Array[LucentContent]) -> LucentContent

LucentContent::tool_use

source

fn LucentContent::tool_use(id : String, name : String, arguments_json : String, arguments_value : Json?) -> LucentContent

LucentContent::video

source

fn LucentContent::video(media_type : String, source : LucentMediaSource) -> LucentContent

LucentConversationItem

source

pub(all) enum LucentConversationItem {
  Message(LucentMessage)
  ToolCall(LucentToolUse)
  ToolResult(LucentToolResult)
  Reasoning(LucentThinking)
  AgentAction(LucentAgentAction)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentConversationItem — 会话项异质平级

LucentConversationItem::agent_action

source

fn LucentConversationItem::agent_action(aa : LucentAgentAction) -> LucentConversationItem

LucentConversationItem::equal

source

fn LucentConversationItem::equal(LucentConversationItem, LucentConversationItem) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentConversationItem::from_json

source

fn LucentConversationItem::from_json(jv : Json) -> Result[LucentConversationItem, String]

=== LucentConversationItem ===

LucentConversationItem::message

source

fn LucentConversationItem::message(msg : LucentMessage) -> LucentConversationItem

LucentConversationItem::reasoning

source

fn LucentConversationItem::reasoning(th : LucentThinking) -> LucentConversationItem

LucentConversationItem::to_json

source

fn LucentConversationItem::to_json(self : LucentConversationItem) -> Json

LucentConversationItem::tool_call

source

fn LucentConversationItem::tool_call(tu : LucentToolUse) -> LucentConversationItem

LucentConversationItem::tool_result

source

fn LucentConversationItem::tool_result(tr : LucentToolResult) -> LucentConversationItem

LucentConversationMeta

source

pub struct LucentConversationMeta {
  id : String?
  model : String?
  usage_input : Int?
  created_at : Int?
  extra : Json?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentConversationMeta — 会话元信息（ConversationStart 携带）

通用字段（所有/多家 provider 共有）：

id：会话/响应 ID
model：模型名
usage_input：输入 token 数
created_at：创建时间戳（OpenAI 系的 created / created_at）

非通用字段通过 extra 透传（如 OpenAI Responses 的 instructions、status 等）。

LucentConversationMeta::equal

source

fn LucentConversationMeta::equal(LucentConversationMeta, LucentConversationMeta) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentConversationMeta::from_json

source

fn LucentConversationMeta::from_json(jv : Json) -> Result[LucentConversationMeta, String]

=== LucentConversationMeta ===

LucentConversationMeta::new

source

fn LucentConversationMeta::new(id : String?, model : String?, usage_input : Int?) -> LucentConversationMeta

LucentConversationMeta::new_full

source

fn LucentConversationMeta::new_full(id : String?, model : String?, usage_input : Int?, created_at : Int?, extra : Json?) -> LucentConversationMeta

创建完整的 LucentConversationMeta（含 created_at 和 extra）

LucentConversationMeta::to_json

source

fn LucentConversationMeta::to_json(self : LucentConversationMeta) -> Json

LucentDiscovery

source

pub struct LucentDiscovery {
  schema_version : String
  protocol_version : String
  schema_url : String
  providers : Array[ProviderCapability]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentDiscovery — 能力发现响应 SDK 接入时第一步调用，获取 Prism 实例的能力清单

LucentDiscovery::equal

source

fn LucentDiscovery::equal(LucentDiscovery, LucentDiscovery) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentDiscovery::from_json

source

fn LucentDiscovery::from_json(jv : Json) -> Result[LucentDiscovery, String]

=== LucentDiscovery ===

LucentDiscovery::new

source

fn LucentDiscovery::new(protocol_version : String, schema_url : String, providers : Array[ProviderCapability]) -> LucentDiscovery

LucentDiscovery::to_json

source

fn LucentDiscovery::to_json(self : LucentDiscovery) -> Json

LucentError

source

pub struct LucentError {
  kind : LucentErrorKind
  message : String
  provider_code : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentError — 错误结构化

LucentError::equal

source

fn LucentError::equal(LucentError, LucentError) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentError::from_json

source

fn LucentError::from_json(jv : Json) -> Result[LucentError, String]

=== LucentError ===

LucentError::new

source

fn LucentError::new(kind : LucentErrorKind, message : String, provider_code : String?) -> LucentError

LucentError::simple

source

fn LucentError::simple(message : String) -> LucentError

LucentError::to_json

source

fn LucentError::to_json(self : LucentError) -> Json

LucentErrorKind

source

pub(all) enum LucentErrorKind {
  RateLimit
  InvalidRequest
  Authentication
  ServerError
  ContentFilter
  Native(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentErrorKind — 错误类型化

LucentErrorKind::equal

source

fn LucentErrorKind::equal(LucentErrorKind, LucentErrorKind) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentErrorKind::from_json

source

fn LucentErrorKind::from_json(jv : Json) -> Result[LucentErrorKind, String]

=== LucentErrorKind ===

LucentErrorKind::from_string

source

fn LucentErrorKind::from_string(s : String) -> LucentErrorKind

LucentErrorKind::to_json

source

fn LucentErrorKind::to_json(self : LucentErrorKind) -> Json

LucentFinishReason

source

pub(all) enum LucentFinishReason {
  Stop
  Length
  ToolCalls
  ContentFilter
  Safety
  Recitation
  MalformedToolCall
  Error
  Native(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentFinishReason — 结束原因

LucentFinishReason::equal

source

fn LucentFinishReason::equal(LucentFinishReason, LucentFinishReason) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentFinishReason::from_json

source

fn LucentFinishReason::from_json(jv : Json) -> Result[LucentFinishReason, String]

=== LucentFinishReason ===

LucentFinishReason::from_string

source

fn LucentFinishReason::from_string(s : String) -> LucentFinishReason

LucentFinishReason 字符串映射（适配器共用）

LucentFinishReason::to_json

source

fn LucentFinishReason::to_json(self : LucentFinishReason) -> Json

LucentFinishReason::to_string

source

fn LucentFinishReason::to_string(self : LucentFinishReason) -> String

LucentMediaSource

source

pub(all) enum LucentMediaSource {
  Inline(String)
  Url(String)
  FileUri(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentMediaSource — 多模态来源三选一

LucentMediaSource::equal

source

fn LucentMediaSource::equal(LucentMediaSource, LucentMediaSource) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentMediaSource::file_uri

source

fn LucentMediaSource::file_uri(uri : String) -> LucentMediaSource

LucentMediaSource::from_json

source

fn LucentMediaSource::from_json(jv : Json) -> Result[LucentMediaSource, String]

=== LucentMediaSource ===

LucentMediaSource::inline

source

fn LucentMediaSource::inline(data : String) -> LucentMediaSource

LucentMediaSource::to_json

source

fn LucentMediaSource::to_json(self : LucentMediaSource) -> Json

LucentMediaSource::url

source

fn LucentMediaSource::url(u : String) -> LucentMediaSource

LucentMessage

source

pub struct LucentMessage {
  role : LucentRole
  content : Array[LucentContent]
  phase : String?
  reasoning : LucentThinking?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentMessage — 消息特例（role + content 块数组）

LucentMessage::equal

source

fn LucentMessage::equal(LucentMessage, LucentMessage) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentMessage::from_json

source

fn LucentMessage::from_json(jv : Json) -> Result[LucentMessage, String]

=== LucentMessage ===

LucentMessage::new

source

fn LucentMessage::new(role : LucentRole, content : Array[LucentContent]) -> LucentMessage

LucentMessage::to_json

source

fn LucentMessage::to_json(self : LucentMessage) -> Json

LucentMessage::with_phase

source

fn LucentMessage::with_phase(role : LucentRole, content : Array[LucentContent], phase : String?) -> LucentMessage

LucentMessage::with_reasoning

source

fn LucentMessage::with_reasoning(role : LucentRole, content : Array[LucentContent], reasoning : LucentThinking?) -> LucentMessage

构造带消息级 reasoning 的 message（openai-chat 等适配器入站使用）

LucentModality

source

pub(all) enum LucentModality {
  Text
  Image
  Audio
  Video
  Pdf
  Native(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentModality — 模态声明

LucentModality::equal

source

fn LucentModality::equal(LucentModality, LucentModality) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentModality::from_json

source

fn LucentModality::from_json(jv : Json) -> Result[LucentModality, String]

=== LucentModality ===

LucentModality::from_string

source

fn LucentModality::from_string(s : String) -> LucentModality?

LucentModality::to_json

source

fn LucentModality::to_json(self : LucentModality) -> Json

LucentMultimedia

source

pub struct LucentMultimedia {
  media_type : String
  source : LucentMediaSource
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentMultimedia — 多模态媒体块

LucentMultimedia::equal

source

fn LucentMultimedia::equal(LucentMultimedia, LucentMultimedia) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentMultimedia::from_json

source

fn LucentMultimedia::from_json(jv : Json) -> Result[LucentMultimedia, String]

=== LucentMultimedia ===

LucentMultimedia::new

source

fn LucentMultimedia::new(media_type : String, source : LucentMediaSource) -> LucentMultimedia

LucentMultimedia::to_json

source

fn LucentMultimedia::to_json(self : LucentMultimedia) -> Json

LucentOptions

source

pub struct LucentOptions {
  temperature : Double?
  top_p : Double?
  top_k : Int?
  max_output_tokens : Int?
  stop : Array[String]?
  stream : Bool
  candidate_count : Int?
  structured_output : LucentStructuredOutput?
  store : Bool?
  previous_response_id : String?
  extras : Map[String, Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentOptions — 生成参数

LucentOptions::default

source

fn LucentOptions::default() -> LucentOptions

LucentOptions::equal

source

fn LucentOptions::equal(LucentOptions, LucentOptions) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentOptions::from_json

source

fn LucentOptions::from_json(jv : Json) -> Result[LucentOptions, String]

=== LucentOptions ===

LucentOptions::new

source

fn LucentOptions::new(temperature : Double?, top_p : Double?, top_k : Int?, max_output_tokens : Int?, stop : Array[String]?, stream : Bool, candidate_count : Int?, structured_output : LucentStructuredOutput?, store : Bool?, extras : Map[String, Json]?) -> LucentOptions

LucentOptions::to_json

source

fn LucentOptions::to_json(self : LucentOptions) -> Json

LucentOptions::with_extras

source

fn LucentOptions::with_extras(self : LucentOptions, extras : Map[String, Json]?) -> LucentOptions

构建含 extras 的选项副本

LucentOptions::with_previous_response_id

source

fn LucentOptions::with_previous_response_id(self : LucentOptions, id : String?) -> LucentOptions

设置 previous_response_id（T8；Responses 有状态续接载体）

LucentOptions::with_store

source

fn LucentOptions::with_store(self : LucentOptions, store : Bool?) -> LucentOptions

构建含 store 值的选项副本

LucentReasoningConfig

source

pub struct LucentReasoningConfig {
  enabled : Bool
  budget_tokens : Int?
  effort : LucentReasoningEffort?
  summary : LucentReasoningSummary?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentReasoningConfig — 推理配置

LucentReasoningConfig::copy_with_budget

source

fn LucentReasoningConfig::copy_with_budget(self : LucentReasoningConfig, budget_tokens : Int?) -> LucentReasoningConfig

构建替换 budget_tokens 的副本（保留其余字段）

LucentReasoningConfig::disabled

source

fn LucentReasoningConfig::disabled() -> LucentReasoningConfig

LucentReasoningConfig::enabled

source

fn LucentReasoningConfig::enabled(budget : Int?) -> LucentReasoningConfig

LucentReasoningConfig::equal

source

fn LucentReasoningConfig::equal(LucentReasoningConfig, LucentReasoningConfig) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentReasoningConfig::from_json

source

fn LucentReasoningConfig::from_json(jv : Json) -> Result[LucentReasoningConfig, String]

=== LucentReasoningConfig ===

LucentReasoningConfig::new

source

fn LucentReasoningConfig::new(effort : LucentReasoningEffort?, summary : LucentReasoningSummary?) -> LucentReasoningConfig

LucentReasoningConfig::to_json

source

fn LucentReasoningConfig::to_json(self : LucentReasoningConfig) -> Json

LucentReasoningEffort

source

pub(all) enum LucentReasoningEffort {
  Low
  Medium
  High
  XHigh
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentReasoningEffort — 推理力度

LucentReasoningEffort::equal

source

fn LucentReasoningEffort::equal(LucentReasoningEffort, LucentReasoningEffort) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentReasoningEffort::from_json

source

fn LucentReasoningEffort::from_json(jv : Json) -> Result[LucentReasoningEffort, String]

=== LucentReasoningEffort ===

LucentReasoningEffort::to_string

source

fn LucentReasoningEffort::to_string(self : LucentReasoningEffort) -> String

LucentReasoningEffort 字符串映射（适配器共用）

出站侧 openai / messages / responses 三处使用完全相同的档位名（"low"/"medium"/"high"/"xhigh"），集中于此避免重复 match。 gemini 的降级映射（XHigh → ("high", true)）语义不同，保留在 adapter。

LucentReasoningSummary

source

pub(all) enum LucentReasoningSummary {
  Auto
  Concise
  Detailed
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentReasoningSummary — 推理摘要详细度

LucentReasoningSummary::equal

source

fn LucentReasoningSummary::equal(LucentReasoningSummary, LucentReasoningSummary) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentReasoningSummary::from_json

source

fn LucentReasoningSummary::from_json(jv : Json) -> Result[LucentReasoningSummary, String]

=== LucentReasoningSummary ===

LucentRequest

source

pub struct LucentRequest {
  schema_version : String
  model : String
  instructions : Array[LucentContent]?
  conversation : Array[LucentConversationItem]
  tools : Array[LucentTool]?
  tool_choice : LucentToolChoice?
  options : LucentOptions
  capabilities : LucentCapabilities?
  reasoning : LucentReasoningConfig?
  metadata : Map[String, String]?
  extra : Map[String, Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentRequest — 完整 LLM 请求

LucentRequest::equal

source

fn LucentRequest::equal(LucentRequest, LucentRequest) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentRequest::from_json

source

fn LucentRequest::from_json(jv : Json) -> Result[LucentRequest, String]

LucentRequest JSON 反序列化

LucentRequest::from_messages

source

fn LucentRequest::from_messages(model : String, instructions : Array[LucentContent]?, messages : Array[LucentMessage], tools : Array[LucentTool]?, tool_choice : LucentToolChoice?, options : LucentOptions, capabilities : LucentCapabilities?, reasoning : LucentReasoningConfig?, metadata : Map[String, String]?, extra : Map[String, Json]?) -> LucentRequest

便利构造器：用 messages 数组（旧风格）替代 conversation

LucentRequest::new

source

fn LucentRequest::new(model : String, instructions : Array[LucentContent]?, conversation : Array[LucentConversationItem], tools : Array[LucentTool]?, tool_choice : LucentToolChoice?, options : LucentOptions, capabilities : LucentCapabilities?, reasoning : LucentReasoningConfig?, metadata : Map[String, String]?, extra : Map[String, Json]?) -> LucentRequest

LucentRequest::to_json

source

fn LucentRequest::to_json(self : LucentRequest) -> Json

LucentRequest JSON 序列化

LucentRequest::validate

source

fn LucentRequest::validate(self : LucentRequest) -> ValidateResult

校验 LucentRequest 的字段值合法性（与 ProviderCapability 无关的基本校验）例如：temperature 范围 [0, 2]，max_output_tokens >= 1，model 非空

LucentRequest::with_conversation

source

fn LucentRequest::with_conversation(self : LucentRequest, conversation : Array[LucentConversationItem]) -> LucentRequest

构建含新 conversation 的请求（子包后处理用）

LucentRequest::with_stream

source

fn LucentRequest::with_stream(self : LucentRequest, stream : Bool) -> LucentRequest

构建含 stream 标志的请求副本（SDK 使用）

LucentResponse

source

pub struct LucentResponse {
  schema_version : String
  id : String
  model : String
  created_at : Int?
  choices : Array[LucentChoice]
  usage : LucentUsage?
  provider_payload : Json?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentResponse — 非流式 LLM 响应

LucentResponse::equal

source

fn LucentResponse::equal(LucentResponse, LucentResponse) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentResponse::from_json

source

fn LucentResponse::from_json(jv : Json) -> Result[LucentResponse, String]

=== LucentResponse ===

LucentResponse::get_text

source

fn LucentResponse::get_text(self : LucentResponse) -> String

提取响应中的纯文本（L1 SDK 使用）

LucentResponse::new

source

fn LucentResponse::new(id : String, model : String, created_at : Int?, choices : Array[LucentChoice], usage : LucentUsage?, provider_payload : Json?) -> LucentResponse

LucentResponse::reasoning

source

fn LucentResponse::reasoning(self : LucentResponse) -> LucentThinking?

便捷访问：首个 choice 的消息级 reasoning（SDK 取用入口）

LucentResponse::to_json

source

fn LucentResponse::to_json(self : LucentResponse) -> Json

LucentResponse::validate

source

fn LucentResponse::validate(self : LucentResponse) -> ValidateResult

校验 LucentResponse 字段合法性

LucentResponse::with_provider_payload

source

fn LucentResponse::with_provider_payload(self : LucentResponse, payload : Json?) -> LucentResponse

构建含 provider_payload 的新响应（外部包访问用）

LucentRole

source

pub(all) enum LucentRole {
  System
  User
  Assistant
  Tool
  Model
  Developer
  Native(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentRole — 对话角色

LucentRole::equal

source

fn LucentRole::equal(LucentRole, LucentRole) -> Bool

显式声明 Eq::equal 保留为常规方法（隐式提升已弃用，见 E0079）

LucentRole::from_json

source

fn LucentRole::from_json(jv : Json) -> Result[LucentRole, String]

LucentRole::from_string

source

fn LucentRole::from_string(s : String) -> LucentRole?

LucentRole::to_json

source

fn LucentRole::to_json(self : LucentRole) -> Json

=== LucentRole ===

LucentRole::to_string

source

fn LucentRole::to_string(self : LucentRole) -> String

LucentSafetyRating

source

pub struct LucentSafetyRating {
  category : String
  probability : String
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentSafetyRating — 安全评级

LucentSafetyRating::equal

source

fn LucentSafetyRating::equal(LucentSafetyRating, LucentSafetyRating) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentSafetyRating::from_json

source

fn LucentSafetyRating::from_json(jv : Json) -> Result[LucentSafetyRating, String]

=== LucentSafetyRating ===

LucentSafetyRating::new

source

fn LucentSafetyRating::new(category : String, probability : String) -> LucentSafetyRating

LucentSafetyRating::to_json

source

fn LucentSafetyRating::to_json(self : LucentSafetyRating) -> Json

LucentStreamEvent

source

pub(all) enum LucentStreamEvent {
  ConversationStart(LucentConversationMeta)
  ItemStart(Int, LucentConversationItem)
  BlockStart(Int, LucentBlockType)
  BlockDelta(Int, LucentBlockDelta)
  BlockEnd(Int)
  ItemEnd(Int)
  BlockDiscard(Int)
  Annotations(Int, Array[LucentAnnotation])
  Finish(LucentFinishReason)
  Usage(LucentUsage)
  Error(LucentError)
  Done
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentStreamEvent — 流事件（canonical：块生命周期）

LucentStreamEvent::equal

source

fn LucentStreamEvent::equal(LucentStreamEvent, LucentStreamEvent) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentStreamEvent::from_json

source

fn LucentStreamEvent::from_json(jv : Json) -> Result[LucentStreamEvent, String]

LucentStreamEvent JSON 反序列化

LucentStreamEvent::to_json

source

fn LucentStreamEvent::to_json(self : LucentStreamEvent) -> Json

LucentStructuredOutput

source

pub(all) enum LucentStructuredOutput {
  JsonObject
  Text
  JsonSchema(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentStructuredOutput — 结构化输出

LucentStructuredOutput::equal

source

fn LucentStructuredOutput::equal(LucentStructuredOutput, LucentStructuredOutput) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentStructuredOutput::from_json

source

fn LucentStructuredOutput::from_json(jv : Json) -> Result[LucentStructuredOutput, String]

=== LucentStructuredOutput ===

LucentStructuredOutput::to_json

source

fn LucentStructuredOutput::to_json(self : LucentStructuredOutput) -> Json

LucentThinking

source

pub struct LucentThinking {
  text : String
  signature : String?
  redacted : Bool
  summary : Array[LucentContent]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentThinking — 推理内容

LucentThinking::equal

source

fn LucentThinking::equal(LucentThinking, LucentThinking) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentThinking::from_json

source

fn LucentThinking::from_json(jv : Json) -> Result[LucentThinking, String]

=== LucentThinking ===

LucentThinking::new

source

fn LucentThinking::new(text : String, signature : String?, redacted : Bool, summary : Array[LucentContent]?) -> LucentThinking

LucentThinking::redacted

source

fn LucentThinking::redacted(signature : String?) -> LucentThinking

LucentThinking::to_json

source

fn LucentThinking::to_json(self : LucentThinking) -> Json

LucentThinking::visible

source

fn LucentThinking::visible(text : String, signature : String?) -> LucentThinking

LucentTool

source

pub struct LucentTool {
  name : String
  description : String?
  parameters_json : String
  strict : Bool?
  kind : LucentToolKind
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentTool — 工具定义

LucentTool::equal

source

fn LucentTool::equal(LucentTool, LucentTool) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentTool::from_json

source

fn LucentTool::from_json(jv : Json) -> Result[LucentTool, String]

=== LucentTool ===

LucentTool::new

source

fn LucentTool::new(name : String, description : String?, parameters_json : String, strict : Bool?, kind : LucentToolKind) -> LucentTool

LucentTool::simple

source

fn LucentTool::simple(name : String, description : String, parameters_json : String) -> LucentTool

LucentTool::to_json

source

fn LucentTool::to_json(self : LucentTool) -> Json

LucentToolChoice

source

pub(all) enum LucentToolChoice {
  Auto
  None
  Required
  SpecificTool(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentToolChoice — 工具选择（类型化）

LucentToolChoice::equal

source

fn LucentToolChoice::equal(LucentToolChoice, LucentToolChoice) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentToolChoice::from_json

source

fn LucentToolChoice::from_json(jv : Json) -> Result[LucentToolChoice, String]

=== LucentToolChoice ===

LucentToolChoice::to_json

source

fn LucentToolChoice::to_json(self : LucentToolChoice) -> Json

LucentToolKind

source

pub(all) enum LucentToolKind {
  Function
  FileSearch
  WebSearch
  CodeInterpreter
  ComputerUse
  CodeExecution
  Shell
  ApplyPatch
  MCP
  Native(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentToolKind — 工具类型（消费方处理逻辑不同）

LucentToolKind::equal

source

fn LucentToolKind::equal(LucentToolKind, LucentToolKind) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentToolResult

source

pub struct LucentToolResult {
  tool_use_id : String
  content : Array[LucentContent]
  is_error : Bool
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentToolResult — 工具结果（多块内容）

LucentToolResult::equal

source

fn LucentToolResult::equal(LucentToolResult, LucentToolResult) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentToolResult::error

source

fn LucentToolResult::error(tool_use_id : String, content : Array[LucentContent]) -> LucentToolResult

LucentToolResult::from_json

source

fn LucentToolResult::from_json(jv : Json) -> Result[LucentToolResult, String]

=== LucentToolResult ===

LucentToolResult::new

source

fn LucentToolResult::new(tool_use_id : String, content : Array[LucentContent], is_error : Bool) -> LucentToolResult

LucentToolResult::ok

source

fn LucentToolResult::ok(tool_use_id : String, content : Array[LucentContent]) -> LucentToolResult

LucentToolResult::to_json

source

fn LucentToolResult::to_json(self : LucentToolResult) -> Json

LucentToolUse

source

pub struct LucentToolUse {
  id : String
  name : String
  arguments_json : String
  arguments_value : Json?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentToolUse — 工具调用（结构化）

LucentToolUse::equal

source

fn LucentToolUse::equal(LucentToolUse, LucentToolUse) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentToolUse::from_json

source

fn LucentToolUse::from_json(jv : Json) -> Result[LucentToolUse, String]

=== LucentToolUse ===

LucentToolUse::new

source

fn LucentToolUse::new(id : String, name : String, arguments_json : String, arguments_value : Json?) -> LucentToolUse

LucentToolUse::to_json

source

fn LucentToolUse::to_json(self : LucentToolUse) -> Json

LucentUsage

source

pub(all) struct LucentUsage {
  prompt_tokens : Int
  completion_tokens : Int
  total_tokens : Int
  reasoning_tokens : Int?
  cached_tokens : Int?
  cache_creation_tokens : Int?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentUsage — Token 用量（面向 reasoning 时代）

LucentUsage::equal

source

fn LucentUsage::equal(LucentUsage, LucentUsage) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

LucentUsage::from_json

source

fn LucentUsage::from_json(jv : Json) -> Result[LucentUsage, String]

LucentResponse JSON 反序列化

LucentUsage::full

source

fn LucentUsage::full(prompt_tokens : Int, completion_tokens : Int, total_tokens : Int, reasoning_tokens : Int?, cached_tokens : Int?, cache_creation_tokens : Int?) -> LucentUsage

构造含细化用量的 LucentUsage（reasoning / cached / cache_creation）

LucentUsage::new

source

fn LucentUsage::new(prompt_tokens : Int, completion_tokens : Int, total_tokens : Int) -> LucentUsage

LucentUsage::to_json

source

fn LucentUsage::to_json(self : LucentUsage) -> Json

LucentResponse JSON 序列化

LucentUsage::with_reasoning

source

fn LucentUsage::with_reasoning(prompt_tokens : Int, completion_tokens : Int, total_tokens : Int, reasoning_tokens : Int) -> LucentUsage

ProviderCapability

source

pub struct ProviderCapability {
  model_pattern : String
  provider : String
  capabilities : LucentCapabilities
  extra_params : Map[String, Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ProviderCapability — 适配器能力声明（SDK 自省用）

ProviderCapability::equal

source

fn ProviderCapability::equal(ProviderCapability, ProviderCapability) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

ProviderCapability::from_json

source

fn ProviderCapability::from_json(jv : Json) -> Result[ProviderCapability, String]

=== ProviderCapability ===

ProviderCapability::new

source

fn ProviderCapability::new(model_pattern : String, provider : String, capabilities : LucentCapabilities, extra_params : Map[String, Json]?) -> ProviderCapability

ProviderCapability::to_json

source

fn ProviderCapability::to_json(self : ProviderCapability) -> Json

ProviderCapability/LucentDiscovery JSON 序列化

SupportLevel

source

pub(all) enum SupportLevel {
  Full
  Partial
  Absent
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

SupportLevel — 能力支持级别替代原有 Bool 能力声明，区分「完全支持 / 部分支持 / 不支持」三档。线格式："full" / "partial" / "none"（Absent 命名避开 Option::None 冲突）。

SupportLevel::equal

source

fn SupportLevel::equal(SupportLevel, SupportLevel) -> Bool

explicit: Eq::equal kept as a regular method (implicit promotion is deprecated, E0079)

SupportLevel::from_json

source

fn SupportLevel::from_json(jv : Json) -> Result[SupportLevel, String]

=== SupportLevel ===

SupportLevel::from_string

source

fn SupportLevel::from_string(s : String) -> SupportLevel?

SupportLevel::to_json

source

fn SupportLevel::to_json(self : SupportLevel) -> Json

SupportLevel::to_string

source

fn SupportLevel::to_string(self : SupportLevel) -> String

ValidateResult

source

pub struct ValidateResult {
  valid : Bool
  errors : Array[String]
  warnings : Array[String]
}

ValidateResult — 校验结果

ValidateResult::error

source

fn ValidateResult::error(msg : String) -> ValidateResult

ValidateResult::ok

source

fn ValidateResult::ok() -> ValidateResult

lucent_collect_annotations

source

fn lucent_collect_annotations(events : Array[LucentStreamEvent]) -> Array[LucentAnnotation]

便利：从 LucentStreamEvent 流中提取所有 Annotations 事件（宿主语言收集标注用）

lucent_content_to_text

source

fn lucent_content_to_text(parts : Array[LucentContent]) -> String

将 LucentContent 数组拼接为纯文本（Text 块拼接，其他块忽略）

lucent_items_from_messages

source

fn lucent_items_from_messages(msgs : Array[LucentMessage]) -> Array[LucentConversationItem]

便利：将 Array[LucentMessage] 包装为 Array[LucentConversationItem]

lucent_messages_from_items

source

fn lucent_messages_from_items(items : Array[LucentConversationItem]) -> Array[LucentMessage]

从 conversation items 中提取所有 Message 项（用于适配器需要 messages 视图的场景）

lucent_stream_events_to_accumulated

source

fn lucent_stream_events_to_accumulated(events : Array[LucentStreamEvent], fallback_id : String, fallback_model : String) -> AccumulatedResponse

完整累加：把流事件合成为 LucentResponse，同时保留 annotations/native_events/agent_actions 及对应诊断。原 lucent_stream_events_to_response 是其薄包装（取 .response）。

lucent_stream_events_to_response

source

fn lucent_stream_events_to_response(events : Array[LucentStreamEvent], fallback_id : String, fallback_model : String) -> LucentResponse

薄包装：取累加结果的 response（既有调用方兼容）

lux_to_json_string

source

fn lux_to_json_string(jv : Json) -> String

push_unsupported

source

fn push_unsupported(field : String, detail : String, diagnostics : Array[ConversionDiagnostic]) -> Unit

构造 unsupported feature 诊断并推入诊断数组

更通用的版本，用于非 content 类型的 unsupported 诊断（如 tools.kind, options.store 等）。

用法：

push_unsupported("tools.kind", "tool kind not supported by gemini", diagnostics)

push_unsupported_content

source

fn push_unsupported_content(type_name : String, adapter : String, diagnostics : Array[ConversionDiagnostic]) -> Unit

构造 unsupported content 诊断并推入诊断数组

统一 ConversionDiagnostic::unsupported("content.xxx", Some("...")) 模式。适配器编码循环中遇到不支持的内容类型时调用。

用法：

push_unsupported_content("audio", "openai-chat", diagnostics)
// 生成: unsupported("content.audio", "audio content not supported by openai-chat")

skip_thinking_when_dual_carrier

source

fn skip_thinking_when_dual_carrier(content : LucentContent, reasoning : LucentThinking?, diagnostics : Array[ConversionDiagnostic]) -> Bool

检测并处理 reasoning dual_carrier 场景

当消息级 reasoning（vLLM/DeepSeek）与 content 中的 Thinking 块并存时，优先使用消息级 reasoning，跳过 content Thinking 块，并记录 Degraded 诊断。

用法：在适配器编码循环中，对每个 content 块调用此函数：

if skip_thinking_when_dual_carrier(content[i], reasoning, diagnostics) {
  i = i + 1
  continue
}

返回 true 表示当前块应跳过（Thinking 块 + reasoning 已存在）。

Source Files

Install

Download zip

A unified LLM protocol middleware converting between OpenAI, Anthropic, Gemini and other provider formats via the Lucent IR neutral protocol

llmwasmprotocolmiddlewareadapter

morning-start

MIT

github.com/morning-start/prism

Updated last month

48 downloads

Site source Report issue Modules Skills CLI Build queue Statistics

#src/lux — Lucent IR 核心包（导航索引）

#文件地图

#1. 类型与构造（先读这里）

#2. 序列化（IR → JSON）

#3. 反序列化（JSON → IR）

#4. 测试

#依赖方向

#约定

#AccumulatedResponse

#AccumulatedResponse::equal

#BlockAccumulator

#BlockAccumulator::discard_block

#BlockAccumulator::ensure_block

#BlockAccumulator::flush_block

#BlockAccumulator::flush_remaining

#BlockAccumulator::new

#ConversationSnapshot

#ConversationSnapshot::equal

#ConversationSnapshot::from_json

#ConversationSnapshot::new

#ConversationSnapshot::to_json

#ConversionDiagnostic

#ConversionDiagnostic::degraded

#ConversionDiagnostic::equal

#ConversionDiagnostic::from_json

#ConversionDiagnostic::new

#ConversionDiagnostic::status

#ConversionDiagnostic::to_json

#ConversionDiagnostic::unsupported

#ConversionResult

#ConversionResult::diagnostics

#ConversionResult::envelope_json

#ConversionResult::equal

#ConversionResult::from_json

#ConversionResult::new

#ConversionResult::to_json

#ConversionResult::value

#ConversionResult::with_diagnostic

#ConversionResult::with_diagnostics

#ConversionStatus

#ConversionStatus::equal

#ConversionStatus::from_json

#ConversionStatus::to_json

#LucentAgentAction

#LucentAgentAction::equal

#LucentAgentAction::from_json

#LucentAgentAction::new

#LucentAgentAction::to_json

#LucentAnnotation

#LucentAnnotation::equal

#LucentAnnotation::from_json

#LucentAnnotation::new

#LucentAnnotation::to_json

#LucentAnnotationKind

#LucentAnnotationKind::equal

#LucentAnnotationKind::from_json

#LucentAnnotationKind::to_json

#LucentBlockDelta

#LucentBlockDelta::equal

#LucentBlockDelta::from_json

#LucentBlockDelta::native_delta

#LucentBlockDelta::refusal_delta

#LucentBlockDelta::signature_delta

#LucentBlockDelta::text_delta

#LucentBlockDelta::thinking_delta

#LucentBlockDelta::to_json

#LucentBlockDelta::tool_arguments_delta

#LucentBlockType

#LucentBlockType::equal

#LucentBlockType::from_json

#LucentBlockType::native

#LucentBlockType::refusal

#LucentBlockType::text

#LucentBlockType::thinking

#LucentBlockType::to_json

#LucentBlockType::tool_call

#LucentCapabilities

#LucentCapabilities::create

#LucentCapabilities::default

#LucentCapabilities::equal

AccumulatedResponse

AccumulatedResponse::equal

BlockAccumulator

BlockAccumulator::discard_block

BlockAccumulator::ensure_block

BlockAccumulator::flush_block

BlockAccumulator::flush_remaining

BlockAccumulator::new

ConversationSnapshot

ConversationSnapshot::equal

ConversationSnapshot::from_json

ConversationSnapshot::new

ConversationSnapshot::to_json

ConversionDiagnostic

ConversionDiagnostic::degraded

ConversionDiagnostic::equal

ConversionDiagnostic::from_json

ConversionDiagnostic::new

ConversionDiagnostic::status

ConversionDiagnostic::to_json

ConversionDiagnostic::unsupported

ConversionResult

ConversionResult::diagnostics

ConversionResult::envelope_json

ConversionResult::equal

ConversionResult::from_json

ConversionResult::new

ConversionResult::to_json

ConversionResult::value

ConversionResult::with_diagnostic

ConversionResult::with_diagnostics

ConversionStatus

ConversionStatus::equal

ConversionStatus::from_json

ConversionStatus::to_json

LucentAgentAction

LucentAgentAction::equal

LucentAgentAction::from_json

LucentAgentAction::new

LucentAgentAction::to_json

LucentAnnotation

LucentAnnotation::equal

LucentAnnotation::from_json

LucentAnnotation::new

LucentAnnotation::to_json

LucentAnnotationKind

LucentAnnotationKind::equal

LucentAnnotationKind::from_json

LucentAnnotationKind::to_json

LucentBlockDelta

LucentBlockDelta::equal

LucentBlockDelta::from_json

LucentBlockDelta::native_delta

LucentBlockDelta::refusal_delta

LucentBlockDelta::signature_delta

LucentBlockDelta::text_delta

LucentBlockDelta::thinking_delta

LucentBlockDelta::to_json

LucentBlockDelta::tool_arguments_delta

LucentBlockType

LucentBlockType::equal

LucentBlockType::from_json

LucentBlockType::native

LucentBlockType::refusal

LucentBlockType::text

LucentBlockType::thinking

LucentBlockType::to_json

LucentBlockType::tool_call

LucentCapabilities

LucentCapabilities::create

LucentCapabilities::default

LucentCapabilities::equal

LucentCapabilities::from_json

LucentCapabilities::to_json

LucentChoice

LucentChoice::equal

LucentChoice::from_json

LucentChoice::new

LucentChoice::to_json

LucentContent