Skip to content

chore: Convert JSON LDValue into the AiConfig Object #61

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 12 commits into
base: lc/SDK-1192/AI-config-feature-branch
Choose a base branch
from
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 23 additions & 0 deletions .github/workflows/java-server-sdk-ai.yml
Original file line number Diff line number Diff line change
@@ -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
Original file line number Diff line number Diff line change
@@ -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) {
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

See comment on AI config. Should be final.

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;
}
}
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Add nullable and nonnull annotations on fields to help with consumption.

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

Original file line number Diff line number Diff line change
@@ -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);
}
}
}
Original file line number Diff line number Diff line change
@@ -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);
}
}
}
Loading