Eino V0.6.1 Released: Removing OpenAPI 3.0 Definition

[mrh997]

Eino V0.6.1 Released

• Following the plan announced in Discussion #397, Eino v0.6.1 is now available.
• Key update: migration from OpenAPI 3.0 Schema Object to JSON Schema and removal of the getkin/kin-openapi dependency and all OpenAPI 3.0–related code.

Removed APIs

• schema/tool.go:
  • NewParamsOneOfByOpenAPIV3()
  • ParamsOneOf.ToOpenAPIV3()
• components/tool/utils/create_options.go:
  • WithSchemaCustomizer()
  • SchemaCustomizerFn

New APIs

• schema/tool.go:
  • NewParamsOneOfByJSONSchema()
  • ParamsOneOf.ToJSONSchema()
• components/tool/utils/create_options.go:
  • WithSchemaModifier()

Upgrade Notes ⚠️

• Issue: some eino-ext modules may report undefined: schema.NewParamsOneOfByOpenAPIV3 and similar errors.
• Solution: upgrade the affected eino-ext modules to their latest versions.

[mrh997]

If migrating to JSON Schema is too complex, consider using these two alternative methods.

OpenAPIV3ToJSONSchema

import (
    "encoding/json"
    "fmt"
    "strconv"

    "github.com/eino-contrib/jsonschema"
    "github.com/getkin/kin-openapi/openapi3"
    orderedmap "github.com/wk8/go-ordered-map/v2"
)

func OpenAPIV3ToJSONSchema(openAPIV3 *openapi3.Schema) (*jsonschema.Schema, error) {
    if openAPIV3 == nil {
       return nil, nil
    }

    js := &jsonschema.Schema{
       Type:          openAPIV3.Type,
       Title:         openAPIV3.Title,
       Format:        openAPIV3.Format,
       Description:   openAPIV3.Description,
       Default:       openAPIV3.Default,
       MaxLength:     openAPIV3.MaxLength,
       UniqueItems:   openAPIV3.UniqueItems,
       ReadOnly:      openAPIV3.ReadOnly,
       WriteOnly:     openAPIV3.WriteOnly,
       Deprecated:    openAPIV3.Deprecated,
       Pattern:       openAPIV3.Pattern,
       MaxItems:      openAPIV3.MaxItems,
       MaxProperties: openAPIV3.MaxProps,
    }

    if openAPIV3.Example != nil {
       js.Examples = []any{openAPIV3.Example}
    }

    if openAPIV3.MinLength > 0 {
       js.MinLength = &openAPIV3.MinLength
    }

    if openAPIV3.MinItems > 0 {
       js.MinItems = &openAPIV3.MinItems
    }

    if openAPIV3.MinProps > 0 {
       js.MinProperties = &openAPIV3.MinProps
    }

    if openAPIV3.OneOf != nil {
       js.OneOf = make([]*jsonschema.Schema, len(openAPIV3.OneOf))
       for i, oneOf := range openAPIV3.OneOf {
          v, err := OpenapiV3ToJSONSchema(oneOf.Value)
          if err != nil {
             return nil, err
          }
          js.OneOf[i] = v
       }
    }

    if openAPIV3.AnyOf != nil {
       js.AnyOf = make([]*jsonschema.Schema, len(openAPIV3.AnyOf))
       for i, anyOf := range openAPIV3.AnyOf {
          v, err := OpenapiV3ToJSONSchema(anyOf.Value)
          if err != nil {
             return nil, err
          }
          js.AnyOf[i] = v
       }
    }

    if openAPIV3.AllOf != nil {
       js.AllOf = make([]*jsonschema.Schema, len(openAPIV3.AllOf))
       for i, allOf := range openAPIV3.AllOf {
          v, err := OpenapiV3ToJSONSchema(allOf.Value)
          if err != nil {
             return nil, err
          }
          js.AllOf[i] = v
       }
    }

    if openAPIV3.Not != nil {
       v, err := OpenapiV3ToJSONSchema(openAPIV3.Not.Value)
       if err != nil {
          return nil, err
       }
       js.Not = v
    }

    if openAPIV3.Min != nil {
       if openAPIV3.ExclusiveMin {
          js.ExclusiveMinimum = json.Number(strconv.FormatFloat(*openAPIV3.Min, 'g', -1, 64))
       } else {
          js.Minimum = json.Number(strconv.FormatFloat(*openAPIV3.Min, 'g', -1, 64))
       }
    }

    if openAPIV3.Max != nil {
       if openAPIV3.ExclusiveMax {
          js.ExclusiveMaximum = json.Number(strconv.FormatFloat(*openAPIV3.Max, 'g', -1, 64))
       } else {
          js.Maximum = json.Number(strconv.FormatFloat(*openAPIV3.Max, 'g', -1, 64))
       }
    }

    if openAPIV3.MultipleOf != nil {
       js.MultipleOf = json.Number(strconv.FormatFloat(*openAPIV3.MultipleOf, 'g', -1, 64))
    }

    if openAPIV3.Enum != nil {
       js.Enum = make([]any, len(openAPIV3.Enum))
       for i, enum := range openAPIV3.Enum {
          js.Enum[i] = enum
       }
    }

    if openAPIV3.Items != nil {
       v, err := OpenapiV3ToJSONSchema(openAPIV3.Items.Value)
       if err != nil {
          return nil, err
       }
       js.Items = v
    }

    if openAPIV3.Properties != nil {
       js.Properties = orderedmap.New[string, *jsonschema.Schema]()
       for k, v := range openAPIV3.Properties {
          if v == nil || v.Value == nil {
             continue
          }
          v_, err := OpenapiV3ToJSONSchema(v.Value)
          if err != nil {
             return nil, err
          }
          js.Properties.Set(k, v_)
       }
    }

    if openAPIV3.Required != nil {
       js.Required = make([]string, len(openAPIV3.Required))
       for i, required := range openAPIV3.Required {
          js.Required[i] = required
       }
    }

    if openAPIV3.AdditionalProperties.Schema != nil {
       v, err := OpenapiV3ToJSONSchema(openAPIV3.AdditionalProperties.Schema.Value)
       if err != nil {
          return nil, err
       }
       js.AdditionalProperties = v
    }

    if openAPIV3.Extensions != nil {
       if js.Extras == nil {
          js.Extras = make(map[string]any, len(openAPIV3.Extensions))
       }

       for k, v := range openAPIV3.Extensions {
          js.Extras[k] = v
       }
    }

    return js, nil
}

JSONSchemaToOpenAPIV3

import (
    "encoding/json"
    "fmt"
    "strconv"

    "github.com/eino-contrib/jsonschema"
    "github.com/getkin/kin-openapi/openapi3"
    orderedmap "github.com/wk8/go-ordered-map/v2"
)

func JSONSchemaToOpenAPIV3(js *jsonschema.Schema) (*openapi3.Schema, error) {
    if js == nil {
       return nil, nil
    }

    openAPIV3 := &openapi3.Schema{
       Type:        js.Type,
       Title:       js.Title,
       Format:      js.Format,
       Description: js.Description,
       Default:     js.Default,
       MaxLength:   js.MaxLength,
       UniqueItems: js.UniqueItems,
       ReadOnly:    js.ReadOnly,
       WriteOnly:   js.WriteOnly,
       Deprecated:  js.Deprecated,
       Pattern:     js.Pattern,
       MaxItems:    js.MaxItems,
       MaxProps:    js.MaxProperties,
    }

    if js.MinLength != nil {
       openAPIV3.MinLength = *js.MinLength
    }

    if js.MinItems != nil {
       openAPIV3.MinItems = *js.MinItems
    }

    if js.MinProperties != nil {
       openAPIV3.MinProps = *js.MinProperties
    }

    if len(js.Examples) > 0 {
       openAPIV3.Example = js.Examples[0]
    }

    if js.OneOf != nil {
       openAPIV3.OneOf = make([]*openapi3.SchemaRef, len(js.OneOf))
       for i, oneOf := range js.OneOf {
          v, err := JSONSchemaToOpenAPIV3(oneOf)
          if err != nil {
             return nil, err
          }
          openAPIV3.OneOf[i] = &openapi3.SchemaRef{
             Ref:   oneOf.Ref,
             Value: v,
          }
       }
    }

    if js.AnyOf != nil {
       openAPIV3.AnyOf = make([]*openapi3.SchemaRef, len(js.AnyOf))
       for i, anyOf := range js.AnyOf {
          v, err := JSONSchemaToOpenAPIV3(anyOf)
          if err != nil {
             return nil, err
          }
          openAPIV3.AnyOf[i] = &openapi3.SchemaRef{
             Ref:   anyOf.Ref,
             Value: v,
          }
       }
    }

    if js.AllOf != nil {
       openAPIV3.AllOf = make([]*openapi3.SchemaRef, len(js.AllOf))
       for i, allOf := range js.AllOf {
          v, err := JSONSchemaToOpenAPIV3(allOf)
          if err != nil {
             return nil, err
          }
          openAPIV3.AllOf[i] = &openapi3.SchemaRef{
             Ref:   allOf.Ref,
             Value: v,
          }
       }
    }

    if js.Not != nil {
       v, err := JSONSchemaToOpenAPIV3(js.Not)
       if err != nil {
          return nil, err
       }
       openAPIV3.Not = &openapi3.SchemaRef{
          Ref:   js.Not.Ref,
          Value: v,
       }
    }
    
    if js.ExclusiveMaximum != "" {
        openAPIV3.ExclusiveMax = true
        max, err := js.ExclusiveMaximum.Float64()
        if err != nil {
           return nil, fmt.Errorf("`ExclusiveMaximum` in JSONSchema must be a number: %w", err)
        }
        openAPIV3.Max = &max
    } else if js.Maximum != "" {
        max, err := js.Maximum.Float64()
        if err != nil {
           return nil, fmt.Errorf("`Maximum` in JSONSchema must be a number: %w", err)
        }
        openAPIV3.Max = &max
    }
    
    if js.ExclusiveMinimum != "" {
        openAPIV3.ExclusiveMin = true
        min, err := js.ExclusiveMinimum.Float64()
        if err != nil {
           return nil, fmt.Errorf("`ExclusiveMinimum` in JSONSchema must be a number: %w", err)
        }
        openAPIV3.Min = &min
    } else if js.Minimum != "" {
        min, err := js.Minimum.Float64()
        if err != nil {
           return nil, fmt.Errorf("`Minimum` in JSONSchema must be a number: %w", err)
        }
        openAPIV3.Min = &min
    }

    if js.MultipleOf != "" {
       multipleOf, err := js.MultipleOf.Float64()
       if err != nil {
          return nil, fmt.Errorf("`MultipleOf` in JSONSchema must be a number: %w", err)
       }
       openAPIV3.MultipleOf = &multipleOf
    }

    if js.Enum != nil {
       openAPIV3.Enum = make([]any, len(js.Enum))
       for i, enum := range js.Enum {
          openAPIV3.Enum[i] = enum
       }
    }

    if js.Items != nil {
       v, err := JSONSchemaToOpenAPIV3(js.Items)
       if err != nil {
          return nil, err
       }
       openAPIV3.Items = &openapi3.SchemaRef{Value: v}
    }

    if js.Properties != nil {
       openAPIV3.Properties = make(map[string]*openapi3.SchemaRef, js.Properties.Len())
       for pair := js.Properties.Oldest(); pair != nil; pair = pair.Next() {
          v, err := JSONSchemaToOpenAPIV3(pair.Value)
          if err != nil {
             return nil, err
          }
          openAPIV3.Properties[pair.Key] = &openapi3.SchemaRef{
             Ref:   pair.Value.Ref,
             Value: v,
          }
       }
    }

    if js.Required != nil {
       openAPIV3.Required = make([]string, len(js.Required))
       for i, required := range js.Required {
          openAPIV3.Required[i] = required
       }
    }

    if js.AdditionalProperties != nil {
       add, err := JSONSchemaToOpenAPIV3(js.AdditionalProperties)
       if err != nil {
          return nil, err
       }
       openAPIV3.AdditionalProperties = openapi3.AdditionalProperties{
          Schema: &openapi3.SchemaRef{
             Ref:   js.AdditionalProperties.Ref,
             Value: add,
          },
       }
    }

    if js.Extras != nil {
       if openAPIV3.Extensions == nil {
          openAPIV3.Extensions = make(map[string]any, len(js.Extras))
       }

       for k, v := range js.Extras {
          openAPIV3.Extensions[k] = v
       }
    }

    return openAPIV3, nil
}