chore: Convert JSON LDValue into the AiConfig Object

.github/workflows/java-server-sdk-ai.yml

@@ -0,0 +1,23 @@
+name: java-server-sdk-ai
+
+on:
+  push:
+    branches: [main, 'feat/**']
+    paths-ignore:
+      - '**.md' #Do not need to run CI for markdown changes.
+  pull_request:
+    branches: [main, 'feat/**', 'lc/**']
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  build-test-java-server-sdk-ai:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Shared CI Steps
+        uses: ./.github/actions/ci
+        with:
+          workspace_path: 'lib/sdk/server-ai'
+          java_version: 8

lib/sdk/server-ai/src/main/java/com/launchdarkly/sdk/server/ai/LDAiClient.java

@@ -1,28 +1,179 @@
 package com.launchdarkly.sdk.server.ai;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Optional;
+
 import com.launchdarkly.logging.LDLogger;
 import com.launchdarkly.sdk.server.interfaces.LDClientInterface;
+import com.launchdarkly.sdk.LDValue;
+import com.launchdarkly.sdk.LDValueType;
+import com.launchdarkly.sdk.server.ai.datamodel.AiConfig;
+import com.launchdarkly.sdk.server.ai.datamodel.Message;
+import com.launchdarkly.sdk.server.ai.datamodel.Meta;
+import com.launchdarkly.sdk.server.ai.datamodel.Model;
+import com.launchdarkly.sdk.server.ai.datamodel.Provider;
 import com.launchdarkly.sdk.server.ai.interfaces.LDAiClientInterface;
 
 /**
- * The LaunchDarkly AI client. The client is capable of retrieving AI Configs from LaunchDarkly,
- * and generating events specific to usage of the AI Config when interacting with model providers.
+ * The LaunchDarkly AI client. The client is capable of retrieving AI Configs
+ * from LaunchDarkly,
+ * and generating events specific to usage of the AI Config when interacting
+ * with model providers.
  */
-public class LDAiClient implements LDAiClientInterface {
+public final class LDAiClient implements LDAiClientInterface {
     private LDClientInterface client;
     private LDLogger logger;
 
     /**
      * Creates a {@link LDAiClient}
      * 
-     * @param client LaunchDarkly Java Server SDK 
+     * @param client LaunchDarkly Java Server SDK
      */
     public LDAiClient(LDClientInterface client) {
-        if(client == null) {
-            //Error
+        if (client == null) {
+            // Error
         } else {
             this.client = client;
             this.logger = client.getLogger();
         }
     }
+
+    /**
+     * Method to convert the JSON variable into the AiConfig object
+     * 
+     * If the parsing failed, the code will log an error and
+     * return a well formed but with nullable value nulled and disabled AIConfig
+     * 
+     * Doing all the error checks, so if somehow LD backend return incorrect value
+     * types, there is logging
+     * This also opens up the possibility of allowing customer to build this using a
+     * JSON string in the future
+     *
+     * @param value
+     * @param key
+     */
+    protected AiConfig parseAiConfig(LDValue value, String key) {
+        boolean enabled = false;
+
+        // Verify the whole value is a JSON object
+        if (!checkValueWithFailureLogging(value, LDValueType.OBJECT, logger,
+                "Input to parseAiConfig must be a JSON object")) {
+            return AiConfig.builder().enabled(enabled).build();
+        }
+
+        // Convert the _meta JSON object into Meta
+        LDValue valueMeta = value.get("_ldMeta");
+        if (!checkValueWithFailureLogging(valueMeta, LDValueType.OBJECT, logger, "_ldMeta must be a JSON object")) {
+            // Q: If we can't read _meta, enabled by spec would be defaulted to false. Does
+            // it even matter the rest of the values?
+            return AiConfig.builder().enabled(enabled).build();
+        }
+
+        // The booleanValue will get false if that value is something that we are not expecting
+        enabled = valueMeta.get("enabled").booleanValue();
+
+        Meta meta = null;
+
+        if (checkValueWithFailureLogging(valueMeta.get("variationKey"), LDValueType.STRING, logger,
+                "variationKey should be a string")) {
+            String variationKey = valueMeta.get("variationKey").stringValue();
+
+            meta = Meta.builder()
+                .variationKey(variationKey)
+                .version(Optional.of(valueMeta.get("version").intValue()))
+                .build();
+        }
+
+        // Convert the optional model from an JSON object of with parameters and custom
+        // into Model
+        Model model = null;
+
+        LDValue valueModel = value.get("model");
+        if (checkValueWithFailureLogging(valueModel, LDValueType.OBJECT, logger,
+                "model if exists must be a JSON object")) {
+            if (checkValueWithFailureLogging(valueModel.get("name"), LDValueType.STRING, logger,
+                    "model name must be a string and is required")) {
+                String modelName = valueModel.get("name").stringValue();
+
+                // Prepare parameters and custom maps for Model
+                HashMap<String, LDValue> parameters = null;
+                HashMap<String, LDValue> custom = null;
+
+                LDValue valueParameters = valueModel.get("parameters");
+                if (checkValueWithFailureLogging(valueParameters, LDValueType.OBJECT, logger,
+                        "non-null parameters must be a JSON object")) {
+                    parameters = new HashMap<>();
+                    for (String k : valueParameters.keys()) {
+                        parameters.put(k, valueParameters.get(k));
+                    }
+                }
+
+                LDValue valueCustom = valueModel.get("custom");
+                if (checkValueWithFailureLogging(valueCustom, LDValueType.OBJECT, logger,
+                        "non-null custom must be a JSON object")) {
+
+                    custom = new HashMap<>();
+                    for (String k : valueCustom.keys()) {
+                        custom.put(k, valueCustom.get(k));
+                    }
+                }
+
+                model = Model.builder()
+                    .name(modelName)
+                    .parameters(parameters)
+                    .custom(custom)
+                    .build();
+            }
+        }
+
+        // Convert the optional messages from an JSON array of JSON objects into Message
+        // Q: Does it even make sense to have 0 messages?
+        List<Message> messages = null;
+
+        LDValue valueMessages = value.get("messages");
+        if (checkValueWithFailureLogging(valueMessages, LDValueType.ARRAY, logger,
+                "messages if exists must be a JSON array")) {
+            messages = new ArrayList<Message>();
+            valueMessages.valuesAs(new Message.MessageConverter());
+            for (Message message : valueMessages.valuesAs(new Message.MessageConverter())) {
+                messages.add(message);
+            }
+        }
+
+        // Convert the optional provider from an JSON object of with name into Provider
+        LDValue valueProvider = value.get("provider");
+        Provider provider = null;
+
+        if (checkValueWithFailureLogging(valueProvider, LDValueType.OBJECT, logger,
+                "non-null provider must be a JSON object")) {
+            if (checkValueWithFailureLogging(valueProvider.get("name"), LDValueType.STRING, logger,
+                    "provider name must be a String")) {
+                String providerName = valueProvider.get("name").stringValue();
+
+                provider = Provider.builder().name(providerName).build();
+            }
+        }
+
+        return AiConfig.builder()
+            .enabled(enabled)
+            .meta(meta)
+            .model(model)
+            .messages(messages)
+            .provider(provider)
+            .build();
+    }
+
+    protected boolean checkValueWithFailureLogging(LDValue ldValue, LDValueType expectedType, LDLogger logger,
+            String message) {
+        if (ldValue.getType() != expectedType) {
+            // TODO: In the next PR, make this required with some sort of default logger
+            if (logger != null) {
+                logger.error(message);
+            }
+            return false;
+        }
+        return true;
+    }
 }

lib/sdk/server-ai/src/main/java/com/launchdarkly/sdk/server/ai/datamodel/AiConfig.java

@@ -0,0 +1,86 @@
+package com.launchdarkly.sdk.server.ai.datamodel;
+
+import java.util.List;
+
+public final class AiConfig {
+    private final boolean enabled;
+
+    private final Meta meta;
+
+    private final Model model;
+
+    private final List<Message> messages;
+
+    private final Provider provider;
+
+    AiConfig(boolean enabled, Meta meta, Model model, List<Message> messages, Provider provider) {
+        this.enabled = enabled;
+        this.meta = meta;
+        this.model = model;
+        this.messages = messages;
+        this.provider = provider;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public List<Message> getMessages() {
+        return messages;
+    }
+
+    public Meta getMeta() {
+        return meta;
+    }
+
+    public Model getModel() {
+        return model;
+    }
+
+    public Provider getProvider() {
+        return provider;
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        private boolean enabled;
+        private Meta meta;
+        private Model model;
+        private List<Message> messages;
+        private Provider provider;
+
+        private Builder() {}
+
+        public Builder enabled(boolean enabled) {
+            this.enabled = enabled;
+            return this;
+        }
+
+        public Builder meta(Meta meta) {
+            this.meta = meta;
+            return this;
+        }
+
+        public Builder model(Model model) {
+            this.model = model;
+            return this;
+        }
+
+        public Builder messages(List<Message> messages) {
+            this.messages = messages;
+            return this;
+        }
+
+        public Builder provider(Provider provider) {
+            this.provider = provider;
+            return this;
+        }
+
+        public AiConfig build() {
+            return new AiConfig(enabled, meta, model, messages, provider);
+        }
+    }
+}

lib/sdk/server-ai/src/main/java/com/launchdarkly/sdk/server/ai/datamodel/Message.java

@@ -0,0 +1,65 @@
+package com.launchdarkly.sdk.server.ai.datamodel;
+
+import com.launchdarkly.sdk.LDValue;
+
+public final class Message {
+    public static class MessageConverter extends LDValue.Converter<Message> {
+        @Override
+        public LDValue fromType(Message message) {
+            return LDValue.buildObject()
+                    .put("content", message.getContent())
+                    .put("role", message.getRole().toString())
+                    .build();
+        }
+
+        @Override
+        public Message toType(LDValue ldValue) {
+            return Message.builder()
+                .content(ldValue.get("content").stringValue())
+                .role(Role.getRole(ldValue.get("role").stringValue()))
+                .build();
+        }
+    }
+
+    private final String content;
+
+    private final Role role;
+
+    Message(String content, Role role) {
+        this.content = content;
+        this.role = role;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public Role getRole() {
+        return role;
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        private String content;
+        private Role role;
+
+        private Builder() {}
+
+        public Builder content(String content) {
+            this.content = content;
+            return this;
+        }
+
+        public Builder role(Role role) {
+            this.role = role;
+            return this;
+        }
+
+        public Message build() {
+            return new Message(content, role);
+        }
+    }
+}