chore: update examples for AI SDK ManagedResult and tracker factory APIs

Migrate examples to the AI SDK API surface introduced by the upcoming
ldai 0.18 / openai 0.4 / langchain 0.5 release stack:

- ManagedModel.invoke() -> .run(); ModelResponse.message.content -> ManagedResult.content
- chat_response.evaluations is a single asyncio.Task[List[JudgeResult]];
  await it directly instead of asyncio.gather over a list
- JudgeResult is a single value (not List); access .sampled / .success /
  .metric_key / .score / .reasoning / .error_message directly
- AIConfig.tracker (field) -> AIConfig.create_tracker() (factory)
- track_metrics_of(metrics_extractor, func) parameter order; use
  track_metrics_of_async for awaited callables (langchain example)
- aiclient.create_judge() is sync; drop the unnecessary `await`
- direct_judge default key updated to `sample-ai-judge` (configured)
- chat_observability now declares launchdarkly-server-sdk-ai-openai as a
  dependency since it uses aiclient.create_model() which loads providers
  via the runner factory

Bumps published version pins to ^0.18 / ^0.4 / ^0.5 to match the new API.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: jsonbailey

examples/chat_observability/chat_observability_example.py

@@ -88,22 +88,22 @@ async def async_main():
         user_input_1 = "What is feature flagging in 2 sentences?"
         print("User Input:", user_input_1)
 
-        response_1 = await chat.invoke(user_input_1)
-        print("Chat Response:", response_1.message.content)
+        response_1 = await chat.run(user_input_1)
+        print("Chat Response:", response_1.content)
 
         user_input_2 = "Give me a specific use case example."
         print("\nUser Input:", user_input_2)
 
-        response_2 = await chat.invoke(user_input_2)
-        print("Chat Response:", response_2.message.content)
+        response_2 = await chat.run(user_input_2)
+        print("Chat Response:", response_2.content)
 
-        # Judge evaluations run asynchronously. Await them (e.g. with asyncio.gather) so they
+        # Judge evaluations run asynchronously. Await them so they
         # complete before the process or request ends—even if you don't need to log or use
         # the results.
-        if response_1.evaluations:
-            await asyncio.gather(*response_1.evaluations)
-        if response_2.evaluations:
-            await asyncio.gather(*response_2.evaluations)
+        if response_1.evaluations is not None:
+            await response_1.evaluations
+        if response_2.evaluations is not None:
+            await response_2.evaluations
 
         print("\nSuccess.")
 

examples/judge/chat_judge_example.py

@@ -1,6 +1,5 @@
 import os
 from dotenv import load_dotenv
-import json
 import asyncio
 import ldclient
 from ldclient import Context
@@ -63,33 +62,38 @@ async def async_main():
         user_input = 'How can LaunchDarkly help me?'
         print("User Input:", user_input)
 
-        # The invoke method will automatically evaluate the chat response with any judges defined in the AI config
-        chat_response = await chat.invoke(user_input)
-        print("Chat Response:", chat_response.message.content)
+        # The run method will automatically evaluate the chat response with any judges defined in the AI config
+        chat_response = await chat.run(user_input)
+        print("Chat Response:", chat_response.content)
 
-        # Judge evaluations run asynchronously. Await them (e.g. with asyncio.gather) so they
-        # complete before the process or request ends—even if you don't need to log or use
-        # the results. Below we await and then log the results for demonstration.
+        # Judge evaluations run asynchronously. Await them so they complete before the
+        # process or request ends—even if you don't need to log or use the results.
+        # Below we await and then log the results for demonstration.
 
         # Log judge evaluation results with full detail
-        if chat_response.evaluations is not None and len(chat_response.evaluations) > 0:
+        if chat_response.evaluations is not None:
             # Note: Judge evaluations run asynchronously and do not block your application.
             # Results are automatically sent to LaunchDarkly for AI config metrics.
             # You only need to await if you want to access the evaluation results in your code.
             print("\nNote: Awaiting judge results (optional - done here for demonstration only).")
-            eval_results = await asyncio.gather(*chat_response.evaluations)
-            
-            # Convert results, replacing None with a message
-            results_to_display = [
-                result.to_dict() if result is not None else "not evaluated" 
-                for result in eval_results
-            ]
-            
+            eval_results = await chat_response.evaluations
+
             print("Judge results:")
-            print(json.dumps(results_to_display, indent=2, default=str))
-            
-            if None in eval_results:
-                print("\nNote: Some judge evaluations were skipped.")
+            for result in eval_results:
+                print(f"  - sampled: {result.sampled}")
+                print(f"    success: {result.success}")
+                if result.error_message is not None:
+                    print(f"    error_message: {result.error_message}")
+                if result.metric_key is not None:
+                    print(f"    metric_key: {result.metric_key}")
+                if result.score is not None:
+                    print(f"    score: {result.score}")
+                if result.reasoning is not None:
+                    print(f"    reasoning: {result.reasoning}")
+
+            skipped = [r for r in eval_results if not r.sampled]
+            if skipped:
+                print("\nNote: Some judge evaluations were skipped (not sampled).")
                 print("This typically happens when the sample rate doesn't require this evaluation, or due to a configuration issue.")
                 print("Check application logs for more details.")
         else:

examples/judge/direct_judge_example.py

@@ -1,6 +1,5 @@
 import os
 from dotenv import load_dotenv
-import json
 import asyncio
 import ldclient
 from ldclient import Context
@@ -13,7 +12,7 @@
 sdk_key = os.getenv('LAUNCHDARKLY_SDK_KEY')
 
 # Set judge_key to the Judge key you want to use.
-judge_key = os.getenv('LAUNCHDARKLY_AI_JUDGE_KEY', 'sample-ai-judge-accuracy')
+judge_key = os.getenv('LAUNCHDARKLY_AI_JUDGE_KEY', 'sample-ai-judge')
 
 
 async def async_main():
@@ -54,8 +53,8 @@ async def async_main():
         #           {'role': 'user', 'content': 'RESPONSE TO EVALUATE: {{response_to_evaluate}}'},
         #       ],
         #   )
-        #   judge = await aiclient.create_judge(judge_key, context, default)
-        judge = await aiclient.create_judge(judge_key, context)
+        #   judge = aiclient.create_judge(judge_key, context, default)
+        judge = aiclient.create_judge(judge_key, context)
 
         if not judge:
             print(f"*** Failed to create judge for key: {judge_key}")
@@ -70,20 +69,26 @@ async def async_main():
 
         judge_response = await judge.evaluate(input_text, output_text)
 
-        if judge_response is None:
-            print("\nJudge evaluation was skipped.")
-            print("This typically happens when the sample rate doesn't require this evaluation, or due to a configuration issue.")
-            print("Check application logs for more details.")
-            return
-
         # Track the judge evaluation scores on the tracker for the aiConfig you are evaluating
         # Example:
         # aiConfig.tracker.track_eval_scores(judge_response.evals)
 
-        # Convert JudgeResponse to dict for display using to_dict()
-        judge_response_dict = judge_response.to_dict()
         print("Judge Response:")
-        print(json.dumps(judge_response_dict, indent=2, default=str))
+        print(f"  sampled: {judge_response.sampled}")
+        print(f"  success: {judge_response.success}")
+        if judge_response.error_message is not None:
+            print(f"  error_message: {judge_response.error_message}")
+        if judge_response.metric_key is not None:
+            print(f"  metric_key: {judge_response.metric_key}")
+        if judge_response.score is not None:
+            print(f"  score: {judge_response.score}")
+        if judge_response.reasoning is not None:
+            print(f"  reasoning: {judge_response.reasoning}")
+
+        if not judge_response.sampled:
+            print("\nNote: Judge evaluation was not sampled.")
+            print("This typically happens when the sample rate doesn't require this evaluation, or due to a configuration issue.")
+            print("Check application logs for more details.")
 
         print("Success.")
     except Exception as err:

examples/langchain/langchain_example.py

@@ -91,9 +91,9 @@ async def async_main():
         messages.append({'role': 'user', 'content': USER_INPUT})
 
         # Track the LangChain completion with LaunchDarkly metrics using the LD LangChain provider's extractor
-        completion = await tracker.track_metrics_of(
-            lambda: llm.ainvoke(messages),
+        completion = await tracker.track_metrics_of_async(
             get_ai_metrics_from_response,
+            lambda: llm.ainvoke(messages),
         )
         ai_response = completion.content
 

examples/openai/openai_example.py

@@ -66,7 +66,7 @@ def main():
         return
 
     tracker = config_value.create_tracker()
-    
+
     messages = [message.to_dict() for message in (config_value.messages or [])]
 
     # Add the user input to the conversation
@@ -76,12 +76,12 @@ def main():
 
     # Track the OpenAI completion with LaunchDarkly metrics using the LD OpenAI provider's extractor
     completion = tracker.track_metrics_of(
+        get_ai_metrics_from_response,
         lambda:
             openai_client.chat.completions.create(
                 model=config_value.model.name,
                 messages=messages,
             ),
-        get_ai_metrics_from_response,
     )
     ai_response = completion.choices[0].message.content