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

syllable_sdk/models/callaction.py

@@ -0,0 +1,116 @@
+"""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 Any, Dict, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+CallActionIf1TypedDict = TypeAliasType(
+    "CallActionIf1TypedDict", Union[CelExpressionTypedDict, JMESPathExpressionTypedDict]
+)
+
+
+CallActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+CallActionIf2TypedDict = TypeAliasType(
+    "CallActionIf2TypedDict",
+    Union[CaseExpressionTypedDict, CallActionIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+CallActionIf2 = TypeAliasType(
+    "CallActionIf2", Union[CaseExpression, CallActionIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+AutoPopulateTypedDict = TypeAliasType("AutoPopulateTypedDict", Union[bool, str])
+r"""Auto-population strategy: True (hybrid - synthetic or LLM), False (always LLM), \"required\" (synthetic only if all required args available, else LLM)"""
+
+
+AutoPopulate = TypeAliasType("AutoPopulate", Union[bool, str])
+r"""Auto-population strategy: True (hybrid - synthetic or LLM), False (always LLM), \"required\" (synthetic only if all required args available, else LLM)"""
+
+
+class CallActionTypedDict(TypedDict):
+    name: str
+    r"""The name of the tool to call."""
+    if_: NotRequired[Nullable[CallActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: Literal["call"]
+    arguments: NotRequired[Nullable[Dict[str, Any]]]
+    r"""Optional arguments to pass to the tool (supports template strings)"""
+    auto_populate: NotRequired[AutoPopulateTypedDict]
+    r"""Auto-population strategy: True (hybrid - synthetic or LLM), False (always LLM), \"required\" (synthetic only if all required args available, else LLM)"""
+
+
+class CallAction(BaseModel):
+    name: str
+    r"""The name of the tool to call."""
+
+    if_: Annotated[OptionalNullable[CallActionIf2], pydantic.Field(alias="if")] = UNSET
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    ACTION: Annotated[
+        Annotated[Optional[Literal["call"]], AfterValidator(validate_const("call"))],
+        pydantic.Field(alias="action"),
+    ] = "call"
+
+    arguments: OptionalNullable[Dict[str, Any]] = UNSET
+    r"""Optional arguments to pass to the tool (supports template strings)"""
+
+    auto_populate: Optional[AutoPopulate] = None
+    r"""Auto-population strategy: True (hybrid - synthetic or LLM), False (always LLM), \"required\" (synthetic only if all required args available, else LLM)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["if", "action", "arguments", "auto_populate"]
+        nullable_fields = ["if", "arguments"]
+        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/caseexpression.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from syllable_sdk.types import BaseModel
+from typing import List, TYPE_CHECKING
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    from .conditionalvalue import ConditionalValue, ConditionalValueTypedDict
+
+
+class CaseExpressionTypedDict(TypedDict):
+    case: List["ConditionalValueTypedDict"]
+
+
+class CaseExpression(BaseModel):
+    case: List["ConditionalValue"]

syllable_sdk/models/celexpression.py

@@ -0,0 +1,31 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from syllable_sdk.types import BaseModel
+from syllable_sdk.utils import validate_const
+from typing import Literal, Optional
+from typing_extensions import Annotated, TypedDict
+
+
+class CelExpressionTypedDict(TypedDict):
+    r"""See https://github.com/google/cel-spec/blob/master/doc/langdef.md"""
+
+    expression: str
+    r"""The expression to evaluate."""
+    type: Literal["cel"]
+    r"""Google Common Expression Language."""
+
+
+class CelExpression(BaseModel):
+    r"""See https://github.com/google/cel-spec/blob/master/doc/langdef.md"""
+
+    expression: str
+    r"""The expression to evaluate."""
+
+    TYPE: Annotated[
+        Annotated[Optional[Literal["cel"]], AfterValidator(validate_const("cel"))],
+        pydantic.Field(alias="type"),
+    ] = "cel"
+    r"""Google Common Expression Language."""

syllable_sdk/models/conditionaltext.py

@@ -0,0 +1,94 @@
+"""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 Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+ConditionalTextIf1TypedDict = TypeAliasType(
+    "ConditionalTextIf1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+ConditionalTextIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+ConditionalTextIf2TypedDict = TypeAliasType(
+    "ConditionalTextIf2TypedDict",
+    Union[CaseExpressionTypedDict, ConditionalTextIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+ConditionalTextIf2 = TypeAliasType(
+    "ConditionalTextIf2", Union[CaseExpression, ConditionalTextIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class ConditionalTextTypedDict(TypedDict):
+    text: str
+    r"""Text to apply if the condition is true."""
+    if_: NotRequired[Nullable[ConditionalTextIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class ConditionalText(BaseModel):
+    text: str
+    r"""Text to apply if the condition is true."""
+
+    if_: Annotated[OptionalNullable[ConditionalTextIf2], pydantic.Field(alias="if")] = (
+        UNSET
+    )
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["if"]
+        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/conditionalvalue.py

@@ -0,0 +1,131 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+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 Any, TYPE_CHECKING, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+if TYPE_CHECKING:
+    from .caseexpression import CaseExpression, CaseExpressionTypedDict
+
+
+ConditionalValueValueFrom1TypedDict = TypeAliasType(
+    "ConditionalValueValueFrom1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+ConditionalValueValueFrom1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+ConditionalValueIf1TypedDict = TypeAliasType(
+    "ConditionalValueIf1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+ConditionalValueIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+ConditionalValueIf2TypedDict = TypeAliasType(
+    "ConditionalValueIf2TypedDict",
+    Union["CaseExpressionTypedDict", ConditionalValueIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+ConditionalValueIf2 = TypeAliasType(
+    "ConditionalValueIf2", Union["CaseExpression", ConditionalValueIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class ConditionalValueTypedDict(TypedDict):
+    value: NotRequired[Nullable[Any]]
+    r"""Initial value of the variable."""
+    value_from: NotRequired[Nullable[ConditionalValueValueFrom2TypedDict]]
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+    if_: NotRequired[Nullable[ConditionalValueIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class ConditionalValue(BaseModel):
+    value: OptionalNullable[Any] = UNSET
+    r"""Initial value of the variable."""
+
+    value_from: OptionalNullable[ConditionalValueValueFrom2] = UNSET
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+
+    if_: Annotated[
+        OptionalNullable[ConditionalValueIf2], pydantic.Field(alias="if")
+    ] = UNSET
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["value", "value_from", "if"]
+        nullable_fields = ["value", "value_from", "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
+
+
+ConditionalValueValueFrom2TypedDict = TypeAliasType(
+    "ConditionalValueValueFrom2TypedDict",
+    Union["CaseExpressionTypedDict", ConditionalValueValueFrom1TypedDict, str],
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+ConditionalValueValueFrom2 = TypeAliasType(
+    "ConditionalValueValueFrom2",
+    Union["CaseExpression", ConditionalValueValueFrom1, str],
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""

syllable_sdk/models/context.py

@@ -0,0 +1,112 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .eventtask import EventTask, EventTaskTypedDict
+from .expressiontask import ExpressionTask, ExpressionTaskTypedDict
+from .loadtoolfromfiletask import LoadToolFromFileTask, LoadToolFromFileTaskTypedDict
+from .stepstask import StepsTask, StepsTaskTypedDict
+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
+
+
+Task2TypedDict = TypeAliasType(
+    "Task2TypedDict",
+    Union[
+        LoadToolFromFileTaskTypedDict,
+        EventTaskTypedDict,
+        StepsTaskTypedDict,
+        ExpressionTaskTypedDict,
+    ],
+)
+
+
+Task2 = Annotated[
+    Union[
+        Annotated[EventTask, Tag("event")],
+        Annotated[ExpressionTask, Tag("expression")],
+        Annotated[LoadToolFromFileTask, Tag("import")],
+        Annotated[StepsTask, Tag("steps")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+Task1TypedDict = TypeAliasType(
+    "Task1TypedDict",
+    Union[
+        LoadToolFromFileTaskTypedDict,
+        EventTaskTypedDict,
+        StepsTaskTypedDict,
+        ExpressionTaskTypedDict,
+    ],
+)
+
+
+Task1 = Annotated[
+    Union[
+        Annotated[EventTask, Tag("event")],
+        Annotated[ExpressionTask, Tag("expression")],
+        Annotated[LoadToolFromFileTask, Tag("import")],
+        Annotated[StepsTask, Tag("steps")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+Task3TypedDict = TypeAliasType(
+    "Task3TypedDict", Union[Task1TypedDict, List[Task2TypedDict]]
+)
+r"""Task implementation details"""
+
+
+Task3 = TypeAliasType("Task3", Union[Task1, List[Task2]])
+r"""Task implementation details"""
+
+
+class ContextTypedDict(TypedDict):
+    task: NotRequired[Nullable[Task3TypedDict]]
+    r"""Task implementation details"""
+
+
+class Context(BaseModel):
+    task: OptionalNullable[Task3] = UNSET
+    r"""Task implementation details"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["task"]
+        nullable_fields = ["task"]
+        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/contexttaskmetadata.py

@@ -0,0 +1,55 @@
+"""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_extensions import NotRequired, TypedDict
+
+
+class ContextTaskMetadataTypedDict(TypedDict):
+    priority: NotRequired[Nullable[int]]
+    parent_tool_name: NotRequired[Nullable[str]]
+    r"""Name of the ToolDefinition that defined this task"""
+
+
+class ContextTaskMetadata(BaseModel):
+    priority: OptionalNullable[int] = UNSET
+
+    parent_tool_name: OptionalNullable[str] = UNSET
+    r"""Name of the ToolDefinition that defined this task"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["priority", "parent_tool_name"]
+        nullable_fields = ["priority", "parent_tool_name"]
+        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/contexttoolinfo.py

@@ -0,0 +1,57 @@
+"""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_extensions import NotRequired, TypedDict
+
+
+class ContextToolInfoTypedDict(TypedDict):
+    name: NotRequired[Nullable[str]]
+    r"""The name of the generated tool."""
+    description: NotRequired[Nullable[str]]
+    r"""The description of the tool."""
+
+
+class ContextToolInfo(BaseModel):
+    name: OptionalNullable[str] = UNSET
+    r"""The name of the generated tool."""
+
+    description: OptionalNullable[str] = UNSET
+    r"""The description of the tool."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["name", "description"]
+        nullable_fields = ["name", "description"]
+        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