New JSON Schema types handling

Author: ddebowczyk

examples/A05_Extras/TranscriptionToTasks/run.php

@@ -62,12 +62,16 @@ class Tasks {
 
 // Step 3: Extract structured data using default language model API (OpenAI)
 print("Extracting structured data using LLM...\n\n");
-$tasks = (new StructuredOutput)->with(
-    messages: $text,
-    responseModel: Tasks::class,
-    model: 'gpt-4o',
-    mode: OutputMode::Json,
-)->get();
+$tasks = (new StructuredOutput)
+    ->withDebugPreset('on')
+    ->with(
+        messages: $text,
+        responseModel: Tasks::class,
+        //model: 'gpt-4o',
+        mode: OutputMode::Json,
+    )
+    ->get();
+dd($tasks);
 
 // Step 4: Now you can use the extracted data in your application
 print("Extracted data:\n");

examples/C07_Misc/ClassificationMulticlass/run.php

@@ -33,23 +33,22 @@ class TicketLabels {
 ?>
 ```
 
-## Classifying Text
+## Classifying Text0
 
 The function `multi_classify` executes multi-label classification using LLM.
 
 ```php
 <?php
 // Perform single-label classification on the input text.
 function multi_classify(string $data) : TicketLabels {
-    return (new StructuredOutput)
-        ->with(
-            messages: [[
-                "role" => "user",
-                "content" => "Label following support ticket: {$data}",
-            ]],
-            responseModel: TicketLabels::class,
-        )
-        ->get();
+    $x = (new StructuredOutput)
+        //->withDebugPreset('on')
+        ->wiretap(fn($e) => $e->printDebug())
+        ->withMessages("Label following support ticket: {$data}")
+        ->withResponseModel(TicketLabels::class)
+        ->create();
+dd($x);
+//        ->get();
 }
 ?>
 ```

packages/polyglot/docs/advanced/json-schema.md

@@ -268,7 +268,7 @@ Available methods include:
 JsonSchema provides various methods to access schema properties:
 
 ```php
-$schema->type();                // Get schema type (string, object, array, etc.)
+$schema->type();                // Get schema type (e.g., 'object')
 $schema->name();                // Get schema name
 $schema->isNullable();          // Check if schema is nullable
 $schema->requiredProperties();  // Get array of required properties

packages/polyglot/src/Embeddings/Drivers/EmbeddingsDriverFactory.php

@@ -51,7 +51,7 @@ public function makeDriver(EmbeddingsConfig $config, HttpClient $httpClient) : C
         $this->events->dispatch(new EmbeddingsDriverBuilt([
             'driver' => get_class($driver),
             'config' => $config->toArray(),
-            'httpClient' => print_r($httpClient, true),
+            'httpClient' => $httpClient ? get_class($httpClient) : null,
         ]));
 
         return $driver($config, $httpClient, $this->events);

packages/polyglot/src/Inference/Drivers/InferenceDriverFactory.php

@@ -92,7 +92,7 @@ public function makeDriver(LLMConfig $config, ?HttpClient $httpClient = null): C
         $this->events->dispatch(new InferenceDriverBuilt([
             'driverClass' => get_class($driver),
             'config' => $config->toArray(),
-            'httpClient' => print_r($httpClient, true),
+            'httpClient' => $httpClient ? get_class($httpClient) : null,
         ]));
 
         return $driver;

packages/schema/src/Data/Traits/TypeDetails/HandlesFactoryMethods.php

@@ -4,7 +4,6 @@
 
 use Cognesy\Schema\Data\TypeDetails;
 use Cognesy\Schema\Factories\TypeDetailsFactory;
-use Cognesy\Utils\JsonSchema\JsonSchema;
 
 trait HandlesFactoryMethods
 {
@@ -60,9 +59,9 @@ public static function fromPhpDocTypeString(string $typeString) : TypeDetails {
         return (new TypeDetailsFactory)->fromPhpDocTypeString($typeString);
     }
 
-    public static function fromJsonSchema(JsonSchema $jsonSchema) : TypeDetails {
-        return (new TypeDetailsFactory)->fromJsonSchema($jsonSchema);
-    }
+//    public static function fromJsonSchema(JsonSchema $jsonSchema) : TypeDetails {
+//        return (new TypeDetailsFactory)->fromJsonSchema($jsonSchema);
+//    }
 
     static public function fromValue(mixed $value) : TypeDetails {
         return (new TypeDetailsFactory)->fromValue($value);

packages/schema/src/Data/Traits/TypeDetails/HandlesJsonTypes.php

@@ -2,33 +2,59 @@
 
 namespace Cognesy\Schema\Data\Traits\TypeDetails;
 
+use Cognesy\Schema\Data\TypeDetails;
 use Cognesy\Utils\JsonSchema\JsonSchema;
+use Cognesy\Utils\JsonSchema\JsonSchemaType;
 
 trait HandlesJsonTypes
 {
-    public function jsonType() : string {
+    public function toJsonType() : JsonSchemaType {
         return match ($this->type) {
-            self::PHP_OBJECT => JsonSchema::JSON_OBJECT,
-            self::PHP_ENUM => ($this->enumType === self::PHP_INT ? JsonSchema::JSON_INTEGER : JsonSchema::JSON_STRING),
-            self::PHP_COLLECTION => JsonSchema::JSON_ARRAY,
-            self::PHP_ARRAY => JsonSchema::JSON_ARRAY,
-            self::PHP_INT => JsonSchema::JSON_INTEGER,
-            self::PHP_FLOAT => JsonSchema::JSON_NUMBER,
-            self::PHP_STRING => JsonSchema::JSON_STRING,
-            self::PHP_BOOL => JsonSchema::JSON_BOOLEAN,
+            self::PHP_OBJECT => JsonSchemaType::object(),
+            self::PHP_ENUM => ($this->enumType === self::PHP_INT ? JsonSchemaType::integer() : JsonSchemaType::string()),
+            self::PHP_COLLECTION => JsonSchemaType::array(),
+            self::PHP_ARRAY => JsonSchemaType::array(),
+            self::PHP_INT => JsonSchemaType::integer(),
+            self::PHP_FLOAT => JsonSchemaType::number(),
+            self::PHP_STRING => JsonSchemaType::string(),
+            self::PHP_BOOL => JsonSchemaType::boolean(),
             default => throw new \Exception('Type not supported: '.$this->type),
         };
     }
 
-    static public function toPhpType(string $jsonType) : string {
-        return match ($jsonType) {
-            JsonSchema::JSON_OBJECT => self::PHP_OBJECT,
-            JsonSchema::JSON_ARRAY => self::PHP_ARRAY,
-            JsonSchema::JSON_INTEGER => self::PHP_INT,
-            JsonSchema::JSON_NUMBER => self::PHP_FLOAT,
-            JsonSchema::JSON_STRING => self::PHP_STRING,
-            JsonSchema::JSON_BOOLEAN => self::PHP_BOOL,
-            default => throw new \Exception('Unknown type: ' . $jsonType),
+    static public function jsonToPhpType(JsonSchemaType $jsonType) : string {
+        return match (true) {
+            $jsonType->isObject() => self::PHP_OBJECT,
+            $jsonType->isArray() => self::PHP_ARRAY,
+            $jsonType->isInteger() => self::PHP_INT,
+            $jsonType->isNumber() => self::PHP_FLOAT,
+            $jsonType->isString() => self::PHP_STRING,
+            $jsonType->isBoolean() => self::PHP_BOOL,
+            default => throw new \Exception('Unknown type: ' . $jsonType->toString()),
+        };
+    }
+
+    static public function fromJson(JsonSchema $json) : TypeDetails {
+        return match (true) {
+            $json->isOption() => TypeDetails::option($json->enumValues()),
+            $json->isObject() && !$json->hasObjectClass() => throw new \Exception('Object must have x-php-class field with the target class name'),
+            $json->isObject() => TypeDetails::object($json->objectClass()),
+            $json->isEnum() => TypeDetails::enum($json->objectClass(), self::jsonToPhpType($json->type()), $json->enumValues()),
+            $json->isCollection() => TypeDetails::collection(match (true) {
+                $json->itemSchema()?->isOption() => TypeDetails::option($json->itemSchema()?->enumValues()),
+                $json->itemSchema()?->isEnum() => $json->itemSchema()?->objectClass(),
+                $json->itemSchema()?->isObject() => $json->itemSchema()?->objectClass(),
+                $json->itemSchema()?->isScalar() => self::jsonToPhpType($json->itemSchema()?->type()),
+                $json->itemSchema()?->isAny() => TypeDetails::mixed(),
+                default => throw new \Exception('Collection item type must be scalar, object or enum: ' . $json->itemSchema()?->type()->toString()),
+            }),
+            $json->isArray() => TypeDetails::array(),
+            $json->isString() => TypeDetails::string(),
+            $json->isBoolean() => TypeDetails::bool(),
+            $json->isInteger() => TypeDetails::int(),
+            $json->isNumber() => TypeDetails::float(),
+            $json->isAny() => TypeDetails::mixed(),
+            default => throw new \Exception('Unknown type: ' . $json->type()->toString()),
         };
     }
 }

packages/schema/src/Data/Traits/TypeDetails/HandlesPhpTypes.php

@@ -4,7 +4,7 @@
 
 trait HandlesPhpTypes
 {
-    static public function getType(mixed $variable) : ?string {
+    static public function getPhpType(mixed $variable) : ?string {
         $type = gettype($variable);
         return self::TYPE_MAP[$type] ?? self::PHP_UNSUPPORTED;
     }