Type mapping

import { UnstructuredText } from '@golemcloud/golem-ts-sdk';
 
async function exampleMethod(
    unstructuredTextWithLanguageCode: UnstructuredText<["en"]>,
): Promise<void> {
    // ...
}

type LanguageCode = string;
 
export type UnstructuredText<LC extends LanguageCode[] = []> =
  | {
      tag: 'url';
      val: string;
    }
  | {
      tag: 'inline';
      val: string;
      languageCode?: LC[number];
    };

use golem_rust::agentic::UnstructuredText;
use golem_rust::AllowedLanguages;
 
fn example_method(
    unstructured_text_with_language_code: UnstructuredText<MyLanguageCode>,
) {
    // ...
}
 
#[derive(Debug, Clone, AllowedLanguages)]
enum MyLanguageCode {
    #[code("en")]
    En,
    #[code("es")]
    Spanish,
    #[code("de")]
    German,
}

use std::fmt::Debug;
 
/// Represents a text value that can either be inline or a URL reference.
///
/// `LC` specifies the allowed language codes for inline text. Defaults to `AnyLanguage`,
/// which allows all languages.
#[derive(Debug, Clone)]
pub enum UnstructuredText<LC: AllowedLanguages = AnyLanguage> {
    Url(String),
    Text {
        text: String,
        language_code: Option<LC>,
    },
}
 
/// Trait for types representing allowed language codes.
///
/// Implement this trait for enums representing supported languages. Provides
/// conversion between enum variants and their string language codes.
/// Use the `#[derive(AllowedLanguages)]` macro to automatically implement this trait.
pub trait AllowedLanguages: Debug + Clone {
    fn all() -> &'static [&'static str];
 
    fn from_language_code(code: &str) -> Option<Self>
    where
        Self: Sized;
 
    fn to_language_code(&self) -> &'static str;
}
 
#[derive(Debug, Clone)]
pub struct AnyLanguage;
 

import golem.data.unstructured.{AllowedLanguages, TextSegment}
import golem.runtime.annotations.languageCode
import golem.runtime.macros.AllowedLanguagesDerivation
 
import scala.concurrent.Future
 
sealed trait MyLanguageCode
object MyLanguageCode {
  @languageCode("en")
  case object En extends MyLanguageCode
 
  @languageCode("es")
  case object Spanish extends MyLanguageCode
 
  @languageCode("de")
  case object German extends MyLanguageCode
 
  given AllowedLanguages[MyLanguageCode] = AllowedLanguagesDerivation.derived
}
 
def exampleMethod(
  unstructuredTextWithLanguageCode: TextSegment[MyLanguageCode]
): Future[Unit] =
  Future.successful(())

trait AllowedLanguages[A] {
  def codes: Option[List[String]]
}
 
object AllowedLanguages {
  sealed trait Any
}
 
final case class TextSegment[Lang](value: UnstructuredTextValue)
 
object TextSegment {
  def inline[Lang](text: String, languageCode: Option[String] = None): TextSegment[Lang] =
    TextSegment(UnstructuredTextValue.Inline(text, languageCode))
 
  def url[Lang](value: String): TextSegment[Lang] =
    TextSegment(UnstructuredTextValue.Url(value))
}

///|
#derive.agent
struct TextAgent {
  name : String
}
 
///|
fn TextAgent::new(name : String) -> TextAgent {
  { name, }
}
 
///|
#derive.text_languages("unstructured_text_with_language_code", "en")
pub fn TextAgent::example_method(
  self : Self,
  unstructured_text_with_language_code : @types.UnstructuredText,
) -> Unit {
  ignore(self)
  ignore(unstructured_text_with_language_code)
}

pub(all) enum UnstructuredText {
  Url(String)
  Inline(text~ : String, language_code~ : String?)
} derive(Show, Eq)
 
pub fn UnstructuredText::from_url(url : String) -> UnstructuredText {
  Url(url)
}
 
pub fn UnstructuredText::from_inline(
  text : String,
  language_code? : String? = None,
) -> UnstructuredText {
  Inline(text~, language_code~)
}

import {
  UnstructuredBinary,
} from '@golemcloud/golem-ts-sdk';
 
async exampleMethod(
  unstructuredBinaryWithMimeType: UnstructuredBinary<['application/json']>,
): Promise<void> {
    // ...
}

type MimeType = string;
 
export type UnstructuredBinary<MT extends MimeType[] | MimeType = MimeType> =
  | {
      tag: 'url';
      val: string;
    }
  | {
      tag: 'inline';
      val: Uint8Array;
      mimeType: MT extends MimeType[] ? MT[number] : MimeType;
    };

use golem_rust::agentic::UnstructuredBinary;
use golem_rust::AllowedMimeTypes;
 
fn example_method(
  unstructured_binary_with_mime_type: UnstructuredBinary<MyMimeType>,
) {
    // ...
}
 
 
#[derive(Debug, Clone, AllowedMimeTypes)]
enum MyMimeType {
   #[mime_type("application/json")]
   ApplicationJson,
   #[mime_type("image/png")]
   ImagePng,
}

 
/// Represents a binary value that can either be inline or a URL reference.
///
/// `MT` specifies the allowed MIME types for inline binary data.
#[derive(Debug, Clone)]
pub enum UnstructuredBinary<MT: AllowedMimeTypes> {
   Url(String),
   Inline { data: Vec<u8>, mime_type: MT },
}
 
/// Trait for types representing allowed MIME types.
///
/// Implement this trait for enums representing supported MIME types. Provides
/// conversion between enum variants and their string MIME type values.
/// Use the `#[derive(AllowedMimeTypes)]` macro to automatically implement this trait.
pub trait AllowedMimeTypes: Debug + Clone {
   fn all() -> &'static [&'static str];
 
   fn from_string(mime_type: &str) -> Option<Self>
   where
       Self: Sized;
 
   fn to_string(&self) -> String;
}

import golem.data.unstructured.{AllowedMimeTypes, BinarySegment}
import golem.runtime.annotations.mimeType
import golem.runtime.macros.AllowedMimeTypesDerivation
 
import scala.concurrent.Future
 
sealed trait MyMimeType
object MyMimeType {
  @mimeType("application/json")
  case object ApplicationJson extends MyMimeType
 
  @mimeType("image/png")
  case object ImagePng extends MyMimeType
 
  given AllowedMimeTypes[MyMimeType] = AllowedMimeTypesDerivation.derived
}
 
def exampleMethod(
  unstructuredBinaryWithMimeType: BinarySegment[MyMimeType]
): Future[Unit] =
  Future.successful(())

trait AllowedMimeTypes[A] {
  def mimeTypes: Option[List[String]]
}
 
object AllowedMimeTypes {
  sealed trait Any
}
 
final case class BinarySegment[Mime](value: UnstructuredBinaryValue)
 
object BinarySegment {
  def inline[Mime](bytes: Array[Byte], mimeType: String): BinarySegment[Mime] =
    BinarySegment(UnstructuredBinaryValue.Inline(bytes, mimeType))
 
  def url[Mime](value: String): BinarySegment[Mime] =
    BinarySegment(UnstructuredBinaryValue.Url(value))
}

///|
#derive.agent
struct BinaryAgent {
  name : String
}
 
///|
fn BinaryAgent::new(name : String) -> BinaryAgent {
  { name, }
}
 
///|
#derive.mime_types("unstructured_binary_with_mime_type", "application/json", "image/png")
pub fn BinaryAgent::example_method(
  self : Self,
  unstructured_binary_with_mime_type : @types.UnstructuredBinary,
) -> Unit {
  ignore(self)
  ignore(unstructured_binary_with_mime_type)
}

pub(all) enum UnstructuredBinary {
  Url(String)
  Inline(data~ : Bytes, mime_type~ : String)
} derive(Show, Eq)
 
pub fn UnstructuredBinary::from_url(url : String) -> UnstructuredBinary {
  Url(url)
}
 
pub fn UnstructuredBinary::from_inline(
  data : Bytes,
  mime_type~ : String,
) -> UnstructuredBinary {
  Inline(data~, mime_type~)
}

 
type MyStructuredData = {
  field1: string;
  field2: number;
}
 
type TextBinaryOrCustom =
  | { tag: 'text'; val: UnstructuredText }
  | { tag: 'binary'; val: UnstructuredBinary }
  | { tag: 'custom'; val: MyStructuredData }
 
async exampleMultimodalMethod(
  input: Multimodal,
): Promise<void> {
  // ...
}
 
async exampleMultimodalCustomMethod(
  input: MultimodalAdvanced<TextBinaryOrCustom>,
): Promise<void> {
  // ...
}
 
async exampleMultimodalAdvanced(
  input: MultimodalAdvanced<TextOrImage>,
): Promise<void> {
  // ...
}
 
export type TextOrImage =
  | { tag: 'text'; val: string }
  | { tag: 'image'; val: Uint8Array }
 

export type MultimodalAdvanced<T> = T[];
 
export type Multimodal = MultimodalAdvanced<BasicModality>;
 
export type MultimodalCustom<T> = MultimodalAdvanced<CustomModality<T>>;
 
export type BasicModality =
  | { tag: 'text'; val: UnstructuredText }
  | { tag: 'binary'; val: UnstructuredBinary }
 
export type CustomModality<T> =
  | { tag: 'text'; val: UnstructuredText }
  | { tag: 'binary'; val: UnstructuredBinary }
  | { tag: 'custom'; val: T }
 

 
use golem_rust::agentic::{Multimodal, MultimodalAdvanced, MultimodalCustom};
use golem_rust::{MultimodalSchema, Schema};
 
fn example_multimodal_method(
  input: Multimodal,
) {
  // ...
}
 
fn example_multimodal_custom_method(
  input: MultimodalCustom<MyStructuredData>,
) {
  // ...
}
 
// MyStructuredData can be used as `T` in MultimodalCustom<T> as long as it implements `Schema`.
#[derive(Schema)]
struct MyStructuredData {
  field1: String,
  field2: u32,
}
 
// When it comes to MultimodalAdvanced with user-defined types, we can define an enum representing the possible types:
// This needs to have an instance of `MultimodalSchema` which can be derived using `#[derive(MultimodalSchema)]`
fn example_multimodal_advanced_method(
  input: MultimodalAdvanced<TextOrImage>,
) {
  // ...
}
 
#[derive(MultimodalSchema)]
enum TextOrImage {
  Text(String),
  Image(Vec<u8>),
}

 
pub struct Multimodal {
    value: MultimodalAdvanced<BasicModality>,
}
 
pub enum BasicModality {
    Text(UnstructuredText),
    Binary(UnstructuredBinary<String>),
}
 
pub struct MultimodalCustom<T: Schema> {
    value: MultimodalAdvanced<CustomModality<T>>,
}
 
pub enum CustomModality<T: Schema> {
    Basic(BasicModality),
    Custom(T),
}
 
 
pub struct MultimodalAdvanced<T: MultimodalSchema> {
    pub items: Vec<T>,
}

import golem.data.multimodal.{Multimodal, MultimodalItems}
import golem.data.unstructured.{AllowedLanguages, AllowedMimeTypes, BinarySegment, TextSegment}
import zio.blocks.schema.Schema
 
import scala.concurrent.Future
 
def exampleMultimodalMethod(
  input: MultimodalItems.Basic
): Future[Unit] =
  Future.successful(())
 
def exampleMultimodalCustomMethod(
  input: MultimodalItems.WithCustom[MyStructuredData]
): Future[Unit] =
  Future.successful(())
 
final case class MyStructuredData(field1: String, field2: Int)
object MyStructuredData {
  implicit val schema: Schema[MyStructuredData] = Schema.derived
}
 
def exampleMultimodalAdvancedMethod(
  input: Multimodal[TextAndImage]
): Future[Unit] =
  Future.successful(())
 
final case class TextAndImage(
  text: TextSegment[AllowedLanguages.Any],
  image: BinarySegment[AllowedMimeTypes.Any]
)
object TextAndImage {
  implicit val schema: Schema[TextAndImage] = Schema.derived
}

final case class Multimodal[A](value: A)
 
sealed trait Modality[+A]
object Modality {
  sealed trait Basic extends Modality[Nothing]
 
  final case class Text(value: UnstructuredTextValue) extends Basic
  final case class Binary(value: UnstructuredBinaryValue) extends Basic
  final case class Custom[A](value: A) extends Modality[A]
}
 
final case class MultimodalItems[+A](items: List[A])
 
object MultimodalItems {
  type Basic = MultimodalItems[Modality.Basic]
  type WithCustom[A] = MultimodalItems[Modality[A]]
}

///|
#derive.golem_schema
pub(all) struct MyStructuredData {
  field1 : String
  field2 : Int
}
 
///|
#derive.multimodal
pub(all) enum TextOrImage {
  Text(String)
  Image(Bytes)
}
 
///|
#derive.agent
struct MultimodalAgent {
  name : String
}
 
///|
fn MultimodalAgent::new(name : String) -> MultimodalAgent {
  { name, }
}
 
///|
pub fn MultimodalAgent::example_multimodal_method(
  self : Self,
  input : @types.Multimodal[@types.TextOrBinary],
) -> Unit {
  ignore(self)
  ignore(input)
}
 
///|
pub fn MultimodalAgent::example_multimodal_custom_method(
  self : Self,
  input : @types.Multimodal[@types.CustomModality[MyStructuredData]],
) -> Unit {
  ignore(self)
  ignore(input)
}
 
///|
pub fn MultimodalAgent::example_multimodal_advanced_method(
  self : Self,
  input : @types.Multimodal[TextOrImage],
) -> Unit {
  ignore(self)
  ignore(input)
}

pub(all) struct Multimodal[T] {
  items : Array[T]
} derive(Show, Eq)
 
pub(all) enum TextOrBinary {
  Text(UnstructuredText)
  Binary(UnstructuredBinary)
} derive(Show, Eq)
 
pub(all) enum CustomModality[T] {
  Text(UnstructuredText)
  Binary(UnstructuredBinary)
  Structured(T)
} derive(Show, Eq)