syllable-sdk 0.41.23__py3-none-any.whl → 0.44.1__py3-none-any.whl

syllable_sdk/models/inputparameter.py

@@ -0,0 +1,106 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+import pydantic
+from pydantic import model_serializer
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from typing import Any, List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class InputParameterType(str, Enum):
+    STRING = "string"
+    NUMBER = "number"
+    INTEGER = "integer"
+    BOOLEAN = "boolean"
+    OBJECT = "object"
+    ARRAY = "array"
+    NULL = "null"
+
+
+class InputParameterTypedDict(TypedDict):
+    name: str
+    r"""The name of the property."""
+    type: NotRequired[Nullable[InputParameterType]]
+    description: NotRequired[Nullable[str]]
+    title: NotRequired[Nullable[str]]
+    format_: NotRequired[Nullable[str]]
+    pattern: NotRequired[Nullable[str]]
+    enum: NotRequired[Nullable[List[str]]]
+    examples: NotRequired[Nullable[List[Any]]]
+    required: NotRequired[bool]
+
+
+class InputParameter(BaseModel):
+    name: str
+    r"""The name of the property."""
+
+    type: OptionalNullable[InputParameterType] = UNSET
+
+    description: OptionalNullable[str] = UNSET
+
+    title: OptionalNullable[str] = UNSET
+
+    format_: Annotated[OptionalNullable[str], pydantic.Field(alias="format")] = UNSET
+
+    pattern: OptionalNullable[str] = UNSET
+
+    enum: OptionalNullable[List[str]] = UNSET
+
+    examples: OptionalNullable[List[Any]] = UNSET
+
+    required: Optional[bool] = True
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "type",
+            "description",
+            "title",
+            "format",
+            "pattern",
+            "enum",
+            "examples",
+            "required",
+        ]
+        nullable_fields = [
+            "type",
+            "description",
+            "title",
+            "format",
+            "pattern",
+            "enum",
+            "examples",
+        ]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/jmespathexpression.py

@@ -0,0 +1,33 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+from syllable_sdk.types import BaseModel
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class JMESPathExpressionType(str, Enum):
+    r"""JMESPath expression."""
+
+    JP = "jp"
+    JMESPATH = "jmespath"
+
+
+class JMESPathExpressionTypedDict(TypedDict):
+    r"""See https://jmespath.org/specification.html#grammar"""
+
+    expression: str
+    r"""The expression to evaluate."""
+    type: NotRequired[JMESPathExpressionType]
+    r"""JMESPath expression."""
+
+
+class JMESPathExpression(BaseModel):
+    r"""See https://jmespath.org/specification.html#grammar"""
+
+    expression: str
+    r"""The expression to evaluate."""
+
+    type: Optional[JMESPathExpressionType] = JMESPathExpressionType.JP
+    r"""JMESPath expression."""

syllable_sdk/models/loadtoolfromfiletask.py

@@ -0,0 +1,112 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .contexttaskmetadata import ContextTaskMetadata, ContextTaskMetadataTypedDict
+from .contexttoolinfo import ContextToolInfo, ContextToolInfoTypedDict
+from .variable import Variable, VariableTypedDict
+import pydantic
+from pydantic import model_serializer
+from pydantic.functional_validators import AfterValidator
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import validate_const
+from typing import Any, Dict, List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+FileTypedDict = TypeAliasType("FileTypedDict", Union[str, List[str]])
+r"""The local path of the tool definition JSON file."""
+
+
+File = TypeAliasType("File", Union[str, List[str]])
+r"""The local path of the tool definition JSON file."""
+
+
+class LoadToolFromFileTaskTypedDict(TypedDict):
+    r"""Bootstraps a tool from a file (for internal developer use only if ENV.local=True)."""
+
+    file: FileTypedDict
+    r"""The local path of the tool definition JSON file."""
+    id: NotRequired[Nullable[str]]
+    r"""A unique identifier for the task."""
+    config: NotRequired[Nullable[Dict[str, Any]]]
+    variables: NotRequired[Nullable[List[VariableTypedDict]]]
+    metadata: NotRequired[Nullable[ContextTaskMetadataTypedDict]]
+    tool: NotRequired[Nullable[ContextToolInfoTypedDict]]
+    type: Literal["import"]
+    version: Literal["v1alpha"]
+
+
+class LoadToolFromFileTask(BaseModel):
+    r"""Bootstraps a tool from a file (for internal developer use only if ENV.local=True)."""
+
+    file: File
+    r"""The local path of the tool definition JSON file."""
+
+    id: OptionalNullable[str] = UNSET
+    r"""A unique identifier for the task."""
+
+    config: OptionalNullable[Dict[str, Any]] = UNSET
+
+    variables: OptionalNullable[List[Variable]] = UNSET
+
+    metadata: OptionalNullable[ContextTaskMetadata] = UNSET
+
+    tool: OptionalNullable[ContextToolInfo] = UNSET
+
+    TYPE: Annotated[
+        Annotated[
+            Optional[Literal["import"]], AfterValidator(validate_const("import"))
+        ],
+        pydantic.Field(alias="type"),
+    ] = "import"
+
+    VERSION: Annotated[
+        Annotated[
+            Optional[Literal["v1alpha"]], AfterValidator(validate_const("v1alpha"))
+        ],
+        pydantic.Field(alias="version"),
+    ] = "v1alpha"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "id",
+            "config",
+            "variables",
+            "metadata",
+            "tool",
+            "type",
+            "version",
+        ]
+        nullable_fields = ["id", "config", "variables", "metadata", "tool"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/nextstep.py

@@ -0,0 +1,97 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .caseexpression import CaseExpression, CaseExpressionTypedDict
+from .celexpression import CelExpression, CelExpressionTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator
+from typing import List, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+NextStepIf1TypedDict = TypeAliasType(
+    "NextStepIf1TypedDict", Union[CelExpressionTypedDict, JMESPathExpressionTypedDict]
+)
+
+
+NextStepIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+NextStepIf2TypedDict = TypeAliasType(
+    "NextStepIf2TypedDict", Union[CaseExpressionTypedDict, NextStepIf1TypedDict, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+NextStepIf2 = TypeAliasType("NextStepIf2", Union[CaseExpression, NextStepIf1, str])
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class NextStepTypedDict(TypedDict):
+    r"""Represents a conditional transition to the next step."""
+
+    id: str
+    r"""The identifier of the next step."""
+    if_: NotRequired[Nullable[NextStepIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    requires: NotRequired[Nullable[List[str]]]
+    r"""List of input field names required for this transition. Validates that specified inputs are collected before allowing transition."""
+
+
+class NextStep(BaseModel):
+    r"""Represents a conditional transition to the next step."""
+
+    id: str
+    r"""The identifier of the next step."""
+
+    if_: Annotated[OptionalNullable[NextStepIf2], pydantic.Field(alias="if")] = UNSET
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    requires: OptionalNullable[List[str]] = UNSET
+    r"""List of input field names required for this transition. Validates that specified inputs are collected before allowing transition."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["if", "requires"]
+        nullable_fields = ["if", "requires"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/pronunciationoverridesdictionary.py

@@ -1,8 +1,11 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .dictionarymetadata import DictionaryMetadata, DictionaryMetadataTypedDict
 from .pronunciationoverride import PronunciationOverride, PronunciationOverrideTypedDict
+from .schemas_tts_v1_pronunciations_dictionarymetadata import (
+    SchemasTtsV1PronunciationsDictionaryMetadata,
+    SchemasTtsV1PronunciationsDictionaryMetadataTypedDict,
+)
 from .voicedisplayinfo import VoiceDisplayInfo, VoiceDisplayInfoTypedDict
 from syllable_sdk.types import BaseModel
 from typing import Dict, List, Optional
@@ -32,7 +35,7 @@ class PronunciationOverridesDictionaryTypedDict(TypedDict):
     """
 
     pronunciations: List[PronunciationOverrideTypedDict]
-    metadata: DictionaryMetadataTypedDict
+    metadata: SchemasTtsV1PronunciationsDictionaryMetadataTypedDict
     r"""Audit metadata associated with a dictionary."""
     type: NotRequired[str]
     voices: NotRequired[Dict[str, VoiceDisplayInfoTypedDict]]
@@ -62,7 +65,7 @@ class PronunciationOverridesDictionary(BaseModel):
 
     pronunciations: List[PronunciationOverride]
 
-    metadata: DictionaryMetadata
+    metadata: SchemasTtsV1PronunciationsDictionaryMetadata
     r"""Audit metadata associated with a dictionary."""
 
     type: Optional[str] = "pronunciations_v1"

syllable_sdk/models/saveaction.py

@@ -0,0 +1,103 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .caseexpression import CaseExpression, CaseExpressionTypedDict
+from .celexpression import CelExpression, CelExpressionTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer
+from pydantic.functional_validators import AfterValidator
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator, validate_const
+from typing import List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+SaveActionIf1TypedDict = TypeAliasType(
+    "SaveActionIf1TypedDict", Union[CelExpressionTypedDict, JMESPathExpressionTypedDict]
+)
+
+
+SaveActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+SaveActionIf2TypedDict = TypeAliasType(
+    "SaveActionIf2TypedDict",
+    Union[CaseExpressionTypedDict, SaveActionIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+SaveActionIf2 = TypeAliasType(
+    "SaveActionIf2", Union[CaseExpression, SaveActionIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class SaveActionTypedDict(TypedDict):
+    if_: NotRequired[Nullable[SaveActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: Literal["save"]
+    name: NotRequired[Nullable[str]]
+    r"""Target name to save (defaults to global variable)."""
+    inputs: NotRequired[Nullable[List[str]]]
+    r"""Input field names to persist; None saves all collected inputs."""
+
+
+class SaveAction(BaseModel):
+    if_: Annotated[OptionalNullable[SaveActionIf2], pydantic.Field(alias="if")] = UNSET
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    ACTION: Annotated[
+        Annotated[Optional[Literal["save"]], AfterValidator(validate_const("save"))],
+        pydantic.Field(alias="action"),
+    ] = "save"
+
+    name: OptionalNullable[str] = UNSET
+    r"""Target name to save (defaults to global variable)."""
+
+    inputs: OptionalNullable[List[str]] = UNSET
+    r"""Input field names to persist; None saves all collected inputs."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["if", "action", "name", "inputs"]
+        nullable_fields = ["if", "name", "inputs"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/sayaction.py

@@ -0,0 +1,108 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .caseexpression import CaseExpression, CaseExpressionTypedDict
+from .celexpression import CelExpression, CelExpressionTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+from enum import Enum
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer
+from pydantic.functional_validators import AfterValidator
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator, validate_const
+from typing import Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+SayActionIf1TypedDict = TypeAliasType(
+    "SayActionIf1TypedDict", Union[CelExpressionTypedDict, JMESPathExpressionTypedDict]
+)
+
+
+SayActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+SayActionIf2TypedDict = TypeAliasType(
+    "SayActionIf2TypedDict", Union[CaseExpressionTypedDict, SayActionIf1TypedDict, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+SayActionIf2 = TypeAliasType("SayActionIf2", Union[CaseExpression, SayActionIf1, str])
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class Role(str, Enum):
+    r"""The role of the message."""
+
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+class SayActionTypedDict(TypedDict):
+    text: str
+    r"""Text to apply if the condition is true."""
+    if_: NotRequired[Nullable[SayActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: Literal["say"]
+    role: NotRequired[Role]
+    r"""The role of the message."""
+
+
+class SayAction(BaseModel):
+    text: str
+    r"""Text to apply if the condition is true."""
+
+    if_: Annotated[OptionalNullable[SayActionIf2], pydantic.Field(alias="if")] = UNSET
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    ACTION: Annotated[
+        Annotated[Optional[Literal["say"]], AfterValidator(validate_const("say"))],
+        pydantic.Field(alias="action"),
+    ] = "say"
+
+    role: Optional[Role] = Role.ASSISTANT
+    r"""The role of the message."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["if", "action", "role"]
+        nullable_fields = ["if"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/schemas_cortex_v1_bridge_phrases_dictionarymetadata.py

@@ -0,0 +1,67 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from pydantic import model_serializer
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class SchemasCortexV1BridgePhrasesDictionaryMetadataTypedDict(TypedDict):
+    r"""Metadata for the bridge phrases dictionary."""
+
+    hash: NotRequired[Nullable[str]]
+    r"""Hash of the dictionary content."""
+    source: NotRequired[Nullable[str]]
+    r"""Source of the dictionary (e.g. filename)."""
+    entries: NotRequired[int]
+    r"""Number of entries in the dictionary."""
+
+
+class SchemasCortexV1BridgePhrasesDictionaryMetadata(BaseModel):
+    r"""Metadata for the bridge phrases dictionary."""
+
+    hash: OptionalNullable[str] = UNSET
+    r"""Hash of the dictionary content."""
+
+    source: OptionalNullable[str] = UNSET
+    r"""Source of the dictionary (e.g. filename)."""
+
+    entries: Optional[int] = 0
+    r"""Number of entries in the dictionary."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["hash", "source", "entries"]
+        nullable_fields = ["hash", "source"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/{dictionarymetadata.py → schemas_tts_v1_pronunciations_dictionarymetadata.py}

@@ -6,7 +6,7 @@ from typing import Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-class DictionaryMetadataTypedDict(TypedDict):
+class SchemasTtsV1PronunciationsDictionaryMetadataTypedDict(TypedDict):
     r"""Audit metadata associated with a dictionary."""
 
     entries: int
@@ -14,7 +14,7 @@ class DictionaryMetadataTypedDict(TypedDict):
     source: NotRequired[str]
 
 
-class DictionaryMetadata(BaseModel):
+class SchemasTtsV1PronunciationsDictionaryMetadata(BaseModel):
     r"""Audit metadata associated with a dictionary."""
 
     entries: int