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

syllable_sdk/models/eventtask.py

@@ -0,0 +1,98 @@
+"""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 .eventtaskevents import EventTaskEvents, EventTaskEventsTypedDict
+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
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class EventTaskTypedDict(TypedDict):
+    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["event"]
+    version: Literal["v1alpha"]
+    on: NotRequired[EventTaskEventsTypedDict]
+
+
+class EventTask(BaseModel):
+    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["event"]], AfterValidator(validate_const("event"))],
+        pydantic.Field(alias="type"),
+    ] = "event"
+
+    VERSION: Annotated[
+        Annotated[
+            Optional[Literal["v1alpha"]], AfterValidator(validate_const("v1alpha"))
+        ],
+        pydantic.Field(alias="version"),
+    ] = "v1alpha"
+
+    on: Optional[EventTaskEvents] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "id",
+            "config",
+            "variables",
+            "metadata",
+            "tool",
+            "type",
+            "version",
+            "on",
+        ]
+        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/eventtaskevents.py

@@ -0,0 +1,83 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .callaction import CallAction, CallActionTypedDict
+from .incrementaction import IncrementAction, IncrementActionTypedDict
+from .saveaction import SaveAction, SaveActionTypedDict
+from .sayaction import SayAction, SayActionTypedDict
+from .setvalueaction import SetValueAction, SetValueActionTypedDict
+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
+
+
+EventTaskEventsStartTypedDict = TypeAliasType(
+    "EventTaskEventsStartTypedDict",
+    Union[
+        SayActionTypedDict,
+        SaveActionTypedDict,
+        IncrementActionTypedDict,
+        SetValueActionTypedDict,
+        CallActionTypedDict,
+    ],
+)
+
+
+EventTaskEventsStart = Annotated[
+    Union[
+        Annotated[CallAction, Tag("call")],
+        Annotated[IncrementAction, Tag("inc")],
+        Annotated[SaveAction, Tag("save")],
+        Annotated[SayAction, Tag("say")],
+        Annotated[SetValueAction, Tag("set")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "action", "action")),
+]
+
+
+class EventTaskEventsTypedDict(TypedDict):
+    start: NotRequired[Nullable[List[EventTaskEventsStartTypedDict]]]
+    r"""Actions to execute on the first input from the user."""
+
+
+class EventTaskEvents(BaseModel):
+    start: OptionalNullable[List[EventTaskEventsStart]] = UNSET
+    r"""Actions to execute on the first input from the user."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["start"]
+        nullable_fields = ["start"]
+        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/expressiontask.py

@@ -0,0 +1,150 @@
+"""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 .contexttaskmetadata import ContextTaskMetadata, ContextTaskMetadataTypedDict
+from .contexttoolinfo import ContextToolInfo, ContextToolInfoTypedDict
+from .expressiontaskevents import ExpressionTaskEvents, ExpressionTaskEventsTypedDict
+from .inputparameter import InputParameter, InputParameterTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+from .variable import Variable, VariableTypedDict
+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 Any, Dict, List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+Expression1TypedDict = TypeAliasType(
+    "Expression1TypedDict", Union[CelExpressionTypedDict, JMESPathExpressionTypedDict]
+)
+
+
+Expression1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+Expression2TypedDict = TypeAliasType(
+    "Expression2TypedDict", Union[CaseExpressionTypedDict, Expression1TypedDict, str]
+)
+
+
+Expression2 = TypeAliasType("Expression2", Union[CaseExpression, Expression1, str])
+
+
+class ExpressionTaskTypedDict(TypedDict):
+    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["expression"]
+    version: Literal["v1alpha"]
+    inputs: NotRequired[List[InputParameterTypedDict]]
+    expression: NotRequired[Nullable[Expression2TypedDict]]
+    output: NotRequired[Nullable[Any]]
+    on: NotRequired[ExpressionTaskEventsTypedDict]
+    r"""Actions to perform when events occur (enter, submit)."""
+
+
+class ExpressionTask(BaseModel):
+    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["expression"]],
+            AfterValidator(validate_const("expression")),
+        ],
+        pydantic.Field(alias="type"),
+    ] = "expression"
+
+    VERSION: Annotated[
+        Annotated[
+            Optional[Literal["v1alpha"]], AfterValidator(validate_const("v1alpha"))
+        ],
+        pydantic.Field(alias="version"),
+    ] = "v1alpha"
+
+    inputs: Optional[List[InputParameter]] = None
+
+    expression: OptionalNullable[Expression2] = UNSET
+
+    output: OptionalNullable[Any] = UNSET
+
+    on: Optional[ExpressionTaskEvents] = None
+    r"""Actions to perform when events occur (enter, submit)."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "id",
+            "config",
+            "variables",
+            "metadata",
+            "tool",
+            "type",
+            "version",
+            "inputs",
+            "expression",
+            "output",
+            "on",
+        ]
+        nullable_fields = [
+            "id",
+            "config",
+            "variables",
+            "metadata",
+            "tool",
+            "expression",
+            "output",
+        ]
+        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/expressiontaskevents.py

@@ -0,0 +1,116 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .callaction import CallAction, CallActionTypedDict
+from .incrementaction import IncrementAction, IncrementActionTypedDict
+from .saveaction import SaveAction, SaveActionTypedDict
+from .sayaction import SayAction, SayActionTypedDict
+from .setvalueaction import SetValueAction, SetValueActionTypedDict
+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
+
+
+ExpressionTaskEventsStartTypedDict = TypeAliasType(
+    "ExpressionTaskEventsStartTypedDict",
+    Union[
+        SayActionTypedDict,
+        SaveActionTypedDict,
+        IncrementActionTypedDict,
+        SetValueActionTypedDict,
+        CallActionTypedDict,
+    ],
+)
+
+
+ExpressionTaskEventsStart = Annotated[
+    Union[
+        Annotated[CallAction, Tag("call")],
+        Annotated[IncrementAction, Tag("inc")],
+        Annotated[SaveAction, Tag("save")],
+        Annotated[SayAction, Tag("say")],
+        Annotated[SetValueAction, Tag("set")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "action", "action")),
+]
+
+
+ExpressionTaskEventsSubmitTypedDict = TypeAliasType(
+    "ExpressionTaskEventsSubmitTypedDict",
+    Union[
+        IncrementActionTypedDict,
+        SayActionTypedDict,
+        SaveActionTypedDict,
+        SetValueActionTypedDict,
+        CallActionTypedDict,
+    ],
+)
+
+
+ExpressionTaskEventsSubmit = Annotated[
+    Union[
+        Annotated[CallAction, Tag("call")],
+        Annotated[IncrementAction, Tag("inc")],
+        Annotated[SaveAction, Tag("save")],
+        Annotated[SayAction, Tag("say")],
+        Annotated[SetValueAction, Tag("set")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "action", "action")),
+]
+
+
+class ExpressionTaskEventsTypedDict(TypedDict):
+    r"""Actions to perform when events occur (enter, submit)."""
+
+    start: NotRequired[Nullable[List[ExpressionTaskEventsStartTypedDict]]]
+    r"""Actions to execute on the first input from the user."""
+    submit: NotRequired[Nullable[List[ExpressionTaskEventsSubmitTypedDict]]]
+    r"""Actions to execute when the tool/step is submitted by the LLM."""
+
+
+class ExpressionTaskEvents(BaseModel):
+    r"""Actions to perform when events occur (enter, submit)."""
+
+    start: OptionalNullable[List[ExpressionTaskEventsStart]] = UNSET
+    r"""Actions to execute on the first input from the user."""
+
+    submit: OptionalNullable[List[ExpressionTaskEventsSubmit]] = UNSET
+    r"""Actions to execute when the tool/step is submitted by the LLM."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["start", "submit"]
+        nullable_fields = ["start", "submit"]
+        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/incrementaction.py

@@ -0,0 +1,106 @@
+"""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 Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+IncrementActionIf1TypedDict = TypeAliasType(
+    "IncrementActionIf1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+IncrementActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+IncrementActionIf2TypedDict = TypeAliasType(
+    "IncrementActionIf2TypedDict",
+    Union[CaseExpressionTypedDict, IncrementActionIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+IncrementActionIf2 = TypeAliasType(
+    "IncrementActionIf2", Union[CaseExpression, IncrementActionIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class IncrementActionTypedDict(TypedDict):
+    name: str
+    r"""Numeric destination path to increment."""
+    if_: NotRequired[Nullable[IncrementActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: Literal["inc"]
+    by: NotRequired[int]
+    r"""Increment amount (defaults to 1)."""
+
+
+class IncrementAction(BaseModel):
+    name: str
+    r"""Numeric destination path to increment."""
+
+    if_: Annotated[OptionalNullable[IncrementActionIf2], pydantic.Field(alias="if")] = (
+        UNSET
+    )
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    ACTION: Annotated[
+        Annotated[Optional[Literal["inc"]], AfterValidator(validate_const("inc"))],
+        pydantic.Field(alias="action"),
+    ] = "inc"
+
+    by: Optional[int] = 1
+    r"""Increment amount (defaults to 1)."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["if", "action", "by"]
+        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/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."""