refactor(ai-formats): group formats by provider

Move protocol/request/response format modules under provider-oriented formats modules and update registry, transport, and architecture paths.

crates/aether-ai-formats/src/formats/openai/embedding/mod.rs

@@ -0,0 +1,2 @@
+pub mod request;
+pub mod response;

crates/aether-ai-formats/src/formats/openai/embedding/request.rs

@@ -0,0 +1,150 @@
+use serde_json::Map;
+use serde_json::Value;
+use std::collections::BTreeMap;
+
+use crate::formats::context::FormatContext;
+use crate::protocol::canonical::{
+    namespace_extension_object, CanonicalEmbeddingInput, CanonicalEmbeddingRequest,
+    CanonicalRequest,
+};
+
+pub fn from(body: &Value, _ctx: &FormatContext) -> Option<CanonicalRequest> {
+    from_namespace(body, "openai")
+}
+
+pub fn to(request: &CanonicalRequest, ctx: &FormatContext) -> Option<Value> {
+    to_openai_like(
+        request,
+        ctx.mapped_model_or(request.model.as_str()),
+        "openai",
+        false,
+    )
+}
+
+pub(crate) fn from_namespace(body_json: &Value, namespace: &str) -> Option<CanonicalRequest> {
+    let request = body_json.as_object()?;
+    let model = request
+        .get("model")
+        .and_then(Value::as_str)
+        .map(str::trim)
+        .filter(|value| !value.is_empty())?
+        .to_string();
+    let input =
+        serde_json::from_value::<CanonicalEmbeddingInput>(request.get("input")?.clone()).ok()?;
+    if input.is_empty() {
+        return None;
+    }
+
+    let embedding = CanonicalEmbeddingRequest {
+        input,
+        encoding_format: request
+            .get("encoding_format")
+            .and_then(Value::as_str)
+            .map(ToOwned::to_owned),
+        dimensions: request.get("dimensions").and_then(Value::as_u64),
+        task: request
+            .get("task")
+            .and_then(Value::as_str)
+            .map(ToOwned::to_owned),
+        user: request
+            .get("user")
+            .and_then(Value::as_str)
+            .map(ToOwned::to_owned),
+        extensions: namespace_extensions(
+            namespace,
+            request,
+            &[
+                "model",
+                "input",
+                "encoding_format",
+                "dimensions",
+                "task",
+                "user",
+            ],
+        ),
+    };
+
+    Some(CanonicalRequest {
+        model,
+        embedding: Some(embedding),
+        ..CanonicalRequest::default()
+    })
+}
+
+pub(crate) fn to_openai_like(
+    canonical: &CanonicalRequest,
+    mapped_model: &str,
+    namespace: &str,
+    default_task: bool,
+) -> Option<Value> {
+    let embedding = canonical.embedding.as_ref()?;
+    if embedding.input.is_empty() {
+        return None;
+    }
+    let mut output = Map::new();
+    output.insert(
+        "model".to_string(),
+        Value::String(mapped_embedding_model(canonical, mapped_model)),
+    );
+    output.insert(
+        "input".to_string(),
+        serde_json::to_value(&embedding.input).ok()?,
+    );
+    if let Some(value) = &embedding.encoding_format {
+        output.insert("encoding_format".to_string(), Value::String(value.clone()));
+    }
+    if let Some(value) = embedding.dimensions {
+        output.insert("dimensions".to_string(), Value::from(value));
+    }
+    if let Some(value) = &embedding.user {
+        output.insert("user".to_string(), Value::String(value.clone()));
+    }
+    if let Some(task) = embedding
+        .task
+        .as_ref()
+        .filter(|value| !value.trim().is_empty())
+    {
+        output.insert("task".to_string(), Value::String(task.clone()));
+    } else if default_task {
+        output.insert(
+            "task".to_string(),
+            Value::String("text-matching".to_string()),
+        );
+    }
+    output.extend(namespace_extension_object(
+        &embedding.extensions,
+        namespace,
+        &output,
+    ));
+    Some(Value::Object(output))
+}
+
+pub(crate) fn mapped_embedding_model(canonical: &CanonicalRequest, mapped_model: &str) -> String {
+    let mapped_model = mapped_model.trim();
+    if mapped_model.is_empty() {
+        canonical.model.clone()
+    } else {
+        mapped_model.to_string()
+    }
+}
+
+pub(crate) fn namespace_extensions(
+    namespace: &str,
+    object: &Map<String, Value>,
+    handled_keys: &[&str],
+) -> BTreeMap<String, Value> {
+    let handled = handled_keys
+        .iter()
+        .copied()
+        .collect::<std::collections::BTreeSet<_>>();
+    let raw = object
+        .iter()
+        .filter(|(key, _)| !handled.contains(key.as_str()))
+        .map(|(key, value)| (key.clone(), value.clone()))
+        .collect::<Map<String, Value>>();
+    if raw.is_empty() {
+        BTreeMap::new()
+    } else {
+        BTreeMap::from([(namespace.to_string(), Value::Object(raw))])
+    }
+}

crates/aether-ai-formats/src/formats/openai/embedding/response.rs

@@ -0,0 +1,106 @@
+use serde_json::Value;
+use serde_json::{json, Map};
+
+use crate::formats::openai::embedding::request::namespace_extensions;
+use crate::protocol::canonical::{
+    canonical_usage_to_openai, namespace_extension_object, openai_usage_to_canonical,
+    CanonicalEmbedding, CanonicalEmbeddingResponse,
+};
+
+pub fn from(body: &Value) -> Option<CanonicalEmbeddingResponse> {
+    from_namespace(body, "openai")
+}
+
+pub fn to(response: &CanonicalEmbeddingResponse) -> Option<Value> {
+    Some(to_openai_like(response, "openai"))
+}
+
+pub(crate) fn from_namespace(
+    body_json: &Value,
+    namespace: &str,
+) -> Option<CanonicalEmbeddingResponse> {
+    let body = body_json.as_object()?;
+    if body.contains_key("error") {
+        return None;
+    }
+    let data = body.get("data")?.as_array()?;
+    let mut embeddings = Vec::new();
+    for (fallback_index, item) in data.iter().enumerate() {
+        let item_object = item.as_object()?;
+        let values = item_object.get("embedding")?.as_array()?;
+        let embedding = values
+            .iter()
+            .map(Value::as_f64)
+            .collect::<Option<Vec<_>>>()?;
+        embeddings.push(CanonicalEmbedding {
+            index: item_object
+                .get("index")
+                .and_then(Value::as_u64)
+                .and_then(|value| usize::try_from(value).ok())
+                .unwrap_or(fallback_index),
+            embedding,
+            extensions: namespace_extensions(
+                namespace,
+                item_object,
+                &["object", "index", "embedding"],
+            ),
+        });
+    }
+    Some(CanonicalEmbeddingResponse {
+        id: body
+            .get("id")
+            .and_then(Value::as_str)
+            .unwrap_or("embd-unknown")
+            .to_string(),
+        model: body
+            .get("model")
+            .and_then(Value::as_str)
+            .unwrap_or("unknown")
+            .to_string(),
+        embeddings,
+        usage: openai_usage_to_canonical(body.get("usage")),
+        extensions: namespace_extensions(
+            namespace,
+            body,
+            &["id", "object", "model", "data", "usage"],
+        ),
+    })
+}
+
+pub(crate) fn to_openai_like(canonical: &CanonicalEmbeddingResponse, namespace: &str) -> Value {
+    let mut response = Map::new();
+    response.insert("object".to_string(), Value::String("list".to_string()));
+    if !canonical.model.trim().is_empty() && canonical.model != "unknown" {
+        response.insert("model".to_string(), Value::String(canonical.model.clone()));
+    }
+    response.insert(
+        "data".to_string(),
+        Value::Array(
+            canonical
+                .embeddings
+                .iter()
+                .map(|embedding| {
+                    let mut item = Map::new();
+                    item.insert("object".to_string(), Value::String("embedding".to_string()));
+                    item.insert("index".to_string(), Value::from(embedding.index as u64));
+                    item.insert("embedding".to_string(), json!(embedding.embedding));
+                    item.extend(namespace_extension_object(
+                        &embedding.extensions,
+                        namespace,
+                        &item,
+                    ));
+                    Value::Object(item)
+                })
+                .collect(),
+        ),
+    );
+    if let Some(usage) = &canonical.usage {
+        response.insert("usage".to_string(), canonical_usage_to_openai(usage));
+    }
+    response.extend(namespace_extension_object(
+        &canonical.extensions,
+        namespace,
+        &response,
+    ));
+    Value::Object(response)
+}