membrane
diff --git a/‎annot/src/main/java/com/predic8/membrane/annot/yaml/parsing/binding/ObjectBinder.java‎
Lines changed: 11 additions & 7 deletions b/‎annot/src/main/java/com/predic8/membrane/annot/yaml/parsing/binding/ObjectBinder.java‎
Lines changed: 11 additions & 7 deletions
diff --git a/‎core/src/main/java/com/predic8/membrane/core/interceptor/llmgateway/AbstractLLMEvent.java‎
Lines changed: 69 additions & 0 deletions b/‎core/src/main/java/com/predic8/membrane/core/interceptor/llmgateway/AbstractLLMEvent.java‎
Lines changed: 69 additions & 0 deletions
diff --git a/‎core/src/main/java/com/predic8/membrane/core/interceptor/llmgateway/ChatCompletionDoneEvent.java‎
Lines changed: 29 additions & 0 deletions b/‎core/src/main/java/com/predic8/membrane/core/interceptor/llmgateway/ChatCompletionDoneEvent.java‎
Lines changed: 29 additions & 0 deletions
diff --git a/‎core/src/main/java/com/predic8/membrane/core/interceptor/llmgateway/ChatCompletionEvent.java‎
Lines changed: 77 additions & 0 deletions b/‎core/src/main/java/com/predic8/membrane/core/interceptor/llmgateway/ChatCompletionEvent.java‎
Lines changed: 77 additions & 0 deletions
diff --git a/‎core/src/main/java/com/predic8/membrane/core/interceptor/llmgateway/DefaultPolicies.java‎
Lines changed: 126 additions & 0 deletions b/‎core/src/main/java/com/predic8/membrane/core/interceptor/llmgateway/DefaultPolicies.java‎
Lines changed: 126 additions & 0 deletions
@@ -33,11 +33,7 @@
 import java.util.List;
 import java.util.Objects;
 
-import static com.predic8.membrane.annot.yaml.McYamlIntrospector.findRequiredSetters;
-import static com.predic8.membrane.annot.yaml.McYamlIntrospector.findSingleSetterOrNullForAnnotation;
-import static com.predic8.membrane.annot.yaml.McYamlIntrospector.getSingleChildSetter;
-import static com.predic8.membrane.annot.yaml.McYamlIntrospector.isCollapsed;
-import static com.predic8.membrane.annot.yaml.McYamlIntrospector.isNoEnvelope;
+import static com.predic8.membrane.annot.yaml.McYamlIntrospector.*;
 import static com.predic8.membrane.annot.yaml.NodeValidationUtils.ensureMappingStart;
 
 public final class ObjectBinder {
@@ -49,7 +45,8 @@ public final class ObjectBinder {
 
     public static <T> T bind(ParsingContext<?> pc, Class<T> clazz, JsonNode node) throws ConfigurationParsingException {
         try {
-            T configObj = clazz.getConstructor().newInstance();
+            T configObj = instantiate(clazz);
+
             BeanDefinition currentBeanDefinition = BeanDefinitionContext.current();
             if (currentBeanDefinition != null && pc.getRegistry() != null) {
                 pc.getRegistry().rememberBeanDefinition(configObj, currentBeanDefinition);
@@ -102,6 +99,14 @@ public static <T> T bind(ParsingContext<?> pc, Class<T> clazz, JsonNode node) th
         }
     }
 
+    private static <T> @NotNull T instantiate(Class<T> clazz) throws InvocationTargetException, InstantiationException, IllegalAccessException {
+        try {
+            return clazz.getConstructor().newInstance();
+        } catch (NoSuchMethodException e) {
+            throw new ConfigurationParsingException("Class %s does not have a public no-arg constructor.".formatted(clazz.getName()));
+        }
+    }
+
     private static <T> @NotNull T handleCollapsed(ParsingContext<?> ctx, Class<T> clazz, JsonNode node, T configObj) {
         if (node.isNull())
             throw new ConfigurationParsingException("Collapsed element must not be null.");
@@ -117,7 +122,6 @@ private static <T> T handleNoEnvelopeList(ParsingContext<?> pc, Class<T> clazz,
         return configObj;
     }
 
-    @SuppressWarnings("ConstantValue")
     private static <T> void applyCollapsedScalar(Class<T> clazz, JsonNode node, T target) {
         Method attributeSetter = findSingleSetterOrNullForAnnotation(clazz, MCAttribute.class);
         Method textSetter = findSingleSetterOrNullForAnnotation(clazz, MCTextContent.class);
 
@@ -0,0 +1,69 @@
+/* Copyright 2026 predic8 GmbH, www.predic8.com
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License. */
+
+package com.predic8.membrane.core.interceptor.llmgateway;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.predic8.membrane.core.util.http.SSEParser;
+import com.predic8.membrane.core.util.json.JsonUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public abstract class AbstractLLMEvent {
+
+    private static final Logger log = LoggerFactory.getLogger(AbstractLLMEvent.class);
+
+    protected static final ObjectMapper om = new ObjectMapper();
+
+    protected final JsonNode json;
+
+    protected AbstractLLMEvent(JsonNode json) {
+        this.json = json;
+    }
+
+    public abstract String getType();
+
+    public JsonNode getJson() {
+        return json;
+    }
+
+    public static AbstractLLMEvent create(SSEParser.SSEEvent sse) {
+
+        if ("[DONE]".equals(sse.data())) {
+            return new ChatCompletionDoneEvent();
+        }
+
+        var opt = JsonUtil.getJsonObject(sse.data());
+        if (opt.isEmpty()) {
+            log.info("Unknown event format: {}", sse.data());
+        }
+
+        var json = opt.get();
+
+        // Responses API
+        if (json.has("type")) {
+            return new ResponsesApiEvent(json);
+        }
+
+        // Chat Completions API
+        if ("chat.completion.chunk".equals(json.path("object").asText())) {
+            return new ChatCompletionEvent(json);
+        }
+
+        log.debug("Unknown event format: {}", json);
+
+        return null;
+    }
+}
@@ -0,0 +1,29 @@
+/* Copyright 2026 predic8 GmbH, www.predic8.com
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License. */
+
+package com.predic8.membrane.core.interceptor.llmgateway;
+
+import com.fasterxml.jackson.databind.node.NullNode;
+
+public class ChatCompletionDoneEvent extends AbstractLLMEvent {
+
+    public ChatCompletionDoneEvent() {
+        super(NullNode.getInstance());
+    }
+
+    @Override
+    public String getType() {
+        return "chat.completion.done";
+    }
+}
@@ -0,0 +1,77 @@
+/* Copyright 2026 predic8 GmbH, www.predic8.com
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License. */
+
+package com.predic8.membrane.core.interceptor.llmgateway;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ChatCompletionEvent extends AbstractLLMEvent {
+
+    private static final Logger log = LoggerFactory.getLogger(ChatCompletionEvent.class);
+
+    public ChatCompletionEvent(JsonNode json) {
+        super(json);
+
+        parseChoices(json);
+
+    }
+
+
+    private static void parseChoices(JsonNode json) {
+        for (JsonNode choice : json.path("choices")) {
+
+            JsonNode delta = choice.path("delta");
+
+            if (delta.has("content")) {
+                log.debug("Content delta: {}",
+                        delta.path("content").asText());
+            }
+
+            if (delta.has("tool_calls")) {
+
+                for (JsonNode tc : delta.path("tool_calls")) {
+
+                    JsonNode fn = tc.path("function");
+
+                    if (fn.has("name")) {
+                        log.debug("Tool call name delta: {}",
+                                fn.path("name").asText());
+                    }
+
+                    if (fn.has("arguments")) {
+                        log.debug("Tool call arguments delta: {}",
+                                fn.path("arguments").asText());
+                    }
+                }
+            }
+
+            String finishReason = choice.path("finish_reason").asText(null);
+
+            if (finishReason != null && !"null".equals(finishReason)) {
+                log.debug("Finish reason: {}", finishReason);
+            }
+        }
+    }
+
+    @Override
+    public String getType() {
+        return "chat.completion.chunk";
+    }
+
+    public JsonNode getChoices() {
+        return json.path("choices");
+    }
+}
@@ -0,0 +1,126 @@
+/* Copyright 2026 predic8 GmbH, www.predic8.com
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License. */
+
+package com.predic8.membrane.core.interceptor.llmgateway;
+
+import com.predic8.membrane.annot.MCAttribute;
+import com.predic8.membrane.annot.MCElement;
+import com.predic8.membrane.core.exchange.Exchange;
+import com.predic8.membrane.core.interceptor.Outcome;
+import com.predic8.membrane.core.interceptor.llmgateway.provider.LLMErrorCreator;
+import com.predic8.membrane.core.interceptor.llmgateway.provider.LLMRequest;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+
+import static com.predic8.membrane.core.interceptor.Outcome.CONTINUE;
+import static com.predic8.membrane.core.interceptor.Outcome.RETURN;
+
+/**
+ * @description LLM Gateway policies for token usage and model restrictions.
+ */
+@MCElement(name = "policies", id="llm-gateway-policies")
+public class DefaultPolicies implements Policies {
+
+    private static final Logger log = LoggerFactory.getLogger(LLMGatewayInterceptor.class);
+
+    private LLMErrorCreator errorCreator;
+
+    private List<String> models;
+    private int maxOutputTokens;
+    private int maxInputTokens;
+
+    public void init(LLMErrorCreator errorCreator) {
+        this.errorCreator = errorCreator;
+    }
+    
+    public Outcome handleRequest(LLMRequest aiReq, Exchange exc) {
+
+        var requestedMaxOutputTokens = aiReq.getRequestedMaxOutputTokens();
+        var inputTokens = aiReq.estimateInputTokens();
+
+        if (maxOutputTokens > 0) {
+            if (requestedMaxOutputTokens <= 0) {
+                log.info("No max. output requested. Setting limit to {}.", maxOutputTokens);
+                aiReq.setMaxOutputTokens(maxOutputTokens);
+            } else if (requestedMaxOutputTokens > maxOutputTokens) {
+                log.info("Requested max. output tokens {} exceed the limit. Setting limit to {}.", requestedMaxOutputTokens, maxOutputTokens);
+                aiReq.setMaxOutputTokens(maxOutputTokens);
+            }
+        }
+
+        if (maxInputTokens != 0) {
+            if (inputTokens > maxInputTokens) {
+                log.info("Input tokens {} exceed the limit of {}.", inputTokens, maxInputTokens);
+                exc.setResponse(errorCreator.inputTokensExceeded(maxInputTokens, inputTokens));
+                return RETURN;
+            }
+        }
+
+        if (models != null) {
+            var model = aiReq.getModel();
+            if (!models.contains(model)) {
+                exc.setResponse(errorCreator.modelNotAllowed(model, models));
+                return RETURN;
+            }
+        }
+
+        return CONTINUE;
+    }
+
+    public List<String> getModels() {
+        return models;
+    }
+
+    /**
+     * @param models List of models that can be used by the gateway.
+     * @desciption Restricts the models that can be used by the gateway.
+     * @default null (no restriction)
+     */
+    @MCAttribute
+    public void setModels(List<String> models) {
+        this.models = models;
+    }
+
+
+    public int getMaxOutputTokens() {
+        return maxOutputTokens;
+    }
+
+    /**
+     * @param maxOutputTokens Maximum number of tokens the LLM should use to generate a response.
+     * @description Maximum number of tokens the LLM should use to generate a response. This is just a hint that the gateway
+     * sends to the LLM provider. The provider may use a different limit.
+     * @default 0 (unlimited)
+     */
+    @MCAttribute
+    public void setMaxOutputTokens(int maxOutputTokens) {
+        this.maxOutputTokens = maxOutputTokens;
+    }
+
+    public int getMaxInputTokens() {
+        return maxInputTokens;
+    }
+
+    /**
+     * @param maxInputTokens Maximum number of tokens that a request can use.
+     * @description Restricts token usage for the input. The size of the input is estimated by gateway based on the request size.
+     * Actual token usage may be deviate from this value.
+     */
+    @MCAttribute
+    public void setMaxInputTokens(int maxInputTokens) {
+        this.maxInputTokens = maxInputTokens;
+    }
+}