mooncakes.io

README

morning-start/prism/lux does not have a README file

#
AccumulatedResponse

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 的辅助信息

#
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::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::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::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::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

=== LucentAgentAction ===

#
LucentAnnotation

source

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

LucentAnnotation — 标注侧信道

#
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

=== LucentAnnotation ===

#
LucentAnnotationKind

source

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

LucentAnnotationKind — 标注类型

#
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

=== LucentAnnotationKind ===

#
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::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 ===

#
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::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

=== LucentBlockType ===

#
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::from_json

source

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

=== LucentCapabilities ===

#
LucentCapabilities::to_json

source

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

=== LucentCapabilities ===

#
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::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

=== LucentChoice ===

#
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::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 ===

#
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::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 ===

#
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?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

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

#
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::to_json

source

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

=== LucentConversationMeta ===

#
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::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

=== LucentDiscovery ===

#
LucentError

source

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

LucentError — 错误结构化

#
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

=== LucentError ===

#
LucentErrorKind

source

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

LucentErrorKind — 错误类型化

#
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

=== LucentErrorKind ===

#
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::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 ===

#
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::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 ===

#
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::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 ===

#
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::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

=== LucentModality ===

#
LucentMultimedia

source

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

LucentMultimedia — 多模态媒体块

#
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

=== LucentMultimedia ===

#
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?
  extras : Map[String, Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LucentOptions — 生成参数

#
LucentOptions::default

source

fn LucentOptions::default() -> LucentOptions

#
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 ===

#
LucentOptions::with_extras

source

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

构建含 extras 的选项副本

#
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::disabled

source

fn LucentReasoningConfig::disabled() -> LucentReasoningConfig

#
LucentReasoningConfig::enabled

source

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

#
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

=== LucentReasoningConfig ===

#
LucentReasoningEffort

source

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

LucentReasoningEffort — 推理力度

#
LucentReasoningEffort::from_json

source

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

=== LucentReasoningEffort ===

#
LucentReasoningSummary

source

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

LucentReasoningSummary — 推理摘要详细度

#
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::from_json

source

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

=== LucentRequest ===

#
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 ===

#
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::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 ===

#
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::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::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

=== LucentSafetyRating ===

#
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::from_json

source

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

=== LucentStreamEvent ===

#
LucentStreamEvent::to_json

source

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

=== LucentStreamEvent ===

#
LucentStructuredOutput

source

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

LucentStructuredOutput — 结构化输出

#
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

=== LucentStructuredOutput ===

#
LucentThinking

source

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

LucentThinking — 推理内容

#
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 ===

#
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::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

=== LucentTool ===

#
LucentToolChoice

source

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

LucentToolChoice — 工具选择（类型化）

#
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

=== LucentToolChoice ===

#
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 — 工具类型（消费方处理逻辑不同）

#
LucentToolResult

source

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

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

#
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

=== LucentToolResult ===

#
LucentToolUse

source

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

LucentToolUse — 工具调用（结构化）

#
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

=== LucentToolUse ===

#
LucentUsage

source

pub 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::from_json

source

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

=== LucentUsage ===

#
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

=== LucentUsage ===

#
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::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 ===

#
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::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 ===

#
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

=== Helper: stringify a Lux type to JSON ===

Source Files

Site source Report issue Packages Build queue Skills Statistics

#AccumulatedResponse

#ConversionDiagnostic

#ConversionDiagnostic::degraded

#ConversionDiagnostic::from_json

#ConversionDiagnostic::new

#ConversionDiagnostic::status

#ConversionDiagnostic::to_json

#ConversionDiagnostic::unsupported

#ConversionResult

#ConversionResult::diagnostics

#ConversionResult::envelope_json

#ConversionResult::from_json

#ConversionResult::new

#ConversionResult::to_json

#ConversionResult::value

#ConversionResult::with_diagnostic

#ConversionResult::with_diagnostics

#ConversionStatus

#ConversionStatus::from_json

#ConversionStatus::to_json

#LucentAgentAction

#LucentAgentAction::from_json

#LucentAgentAction::new

#LucentAgentAction::to_json

#LucentAnnotation

#LucentAnnotation::from_json

#LucentAnnotation::new

#LucentAnnotation::to_json

#LucentAnnotationKind

#LucentAnnotationKind::from_json

#LucentAnnotationKind::to_json

#LucentBlockDelta

#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::from_json

#LucentBlockType::native

#LucentBlockType::refusal

#LucentBlockType::text

#LucentBlockType::thinking

#LucentBlockType::to_json

#LucentBlockType::tool_call

#LucentCapabilities

#LucentCapabilities::create

#LucentCapabilities::default

#LucentCapabilities::from_json

#LucentCapabilities::to_json

#LucentChoice

#LucentChoice::from_json

#LucentChoice::new

#LucentChoice::to_json

#LucentContent

#LucentContent::audio

#LucentContent::file

#LucentContent::from_json

#LucentContent::image

#LucentContent::native

#LucentContent::redacted_thinking

#LucentContent::refusal

#LucentContent::text

#LucentContent::text_with_annotations

#LucentContent::thinking

#LucentContent::to_json

#LucentContent::tool_result

#LucentContent::tool_result_error

#LucentContent::tool_use

#LucentContent::video

#LucentConversationItem

#LucentConversationItem::agent_action

#LucentConversationItem::from_json

#LucentConversationItem::message

#LucentConversationItem::reasoning

#LucentConversationItem::to_json

#LucentConversationItem::tool_call

#
AccumulatedResponse

#
ConversionDiagnostic

#
ConversionDiagnostic::degraded

#
ConversionDiagnostic::from_json

#
ConversionDiagnostic::new

#
ConversionDiagnostic::status

#
ConversionDiagnostic::to_json

#
ConversionDiagnostic::unsupported

#
ConversionResult

#
ConversionResult::diagnostics

#
ConversionResult::envelope_json

#
ConversionResult::from_json

#
ConversionResult::new

#
ConversionResult::to_json

#
ConversionResult::value

#
ConversionResult::with_diagnostic

#
ConversionResult::with_diagnostics

#
ConversionStatus

#
ConversionStatus::from_json

#
ConversionStatus::to_json

#
LucentAgentAction

#
LucentAgentAction::from_json

#
LucentAgentAction::new

#
LucentAgentAction::to_json

#
LucentAnnotation

#
LucentAnnotation::from_json

#
LucentAnnotation::new

#
LucentAnnotation::to_json

#
LucentAnnotationKind

#
LucentAnnotationKind::from_json

#
LucentAnnotationKind::to_json

#
LucentBlockDelta

#
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::from_json

#
LucentBlockType::native

#
LucentBlockType::refusal

#
LucentBlockType::text

#
LucentBlockType::thinking

#
LucentBlockType::to_json

#
LucentBlockType::tool_call

#
LucentCapabilities

#
LucentCapabilities::create

#
LucentCapabilities::default

#
LucentCapabilities::from_json

#
LucentCapabilities::to_json

#
LucentChoice

#
LucentChoice::from_json

#
LucentChoice::new

#
LucentChoice::to_json

#
LucentContent

#
LucentContent::audio

#
LucentContent::file

#
LucentContent::from_json

#
LucentContent::image

#
LucentContent::native

#
LucentContent::redacted_thinking

#
LucentContent::refusal

#
LucentContent::text

#
LucentContent::text_with_annotations

#
LucentContent::thinking

#
LucentContent::to_json

#
LucentContent::tool_result

#
LucentContent::tool_result_error

#
LucentContent::tool_use

#
LucentContent::video

#
LucentConversationItem

#
LucentConversationItem::agent_action

#
LucentConversationItem::from_json

#
LucentConversationItem::message

#
LucentConversationItem::reasoning

#
LucentConversationItem::to_json

#
LucentConversationItem::tool_call