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

syllable_sdk/models/stepeventactions.py

@@ -0,0 +1,145 @@
+"""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
+
+
+StepEventActionsStartTypedDict = TypeAliasType(
+    "StepEventActionsStartTypedDict",
+    Union[
+        SayActionTypedDict,
+        SaveActionTypedDict,
+        IncrementActionTypedDict,
+        SetValueActionTypedDict,
+        CallActionTypedDict,
+    ],
+)
+
+
+StepEventActionsStart = 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")),
+]
+
+
+EnterTypedDict = TypeAliasType(
+    "EnterTypedDict",
+    Union[
+        IncrementActionTypedDict,
+        SayActionTypedDict,
+        SaveActionTypedDict,
+        SetValueActionTypedDict,
+        CallActionTypedDict,
+    ],
+)
+
+
+Enter = 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")),
+]
+
+
+StepEventActionsSubmitTypedDict = TypeAliasType(
+    "StepEventActionsSubmitTypedDict",
+    Union[
+        IncrementActionTypedDict,
+        SayActionTypedDict,
+        SaveActionTypedDict,
+        SetValueActionTypedDict,
+        CallActionTypedDict,
+    ],
+)
+
+
+StepEventActionsSubmit = 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 StepEventActionsTypedDict(TypedDict):
+    r"""Actions to perform when events occur (enter, submit)."""
+
+    start: NotRequired[Nullable[List[StepEventActionsStartTypedDict]]]
+    r"""Actions to execute on the first input from the user."""
+    enter: NotRequired[Nullable[List[EnterTypedDict]]]
+    r"""Actions to execute when entering a step (before collecting inputs)."""
+    submit: NotRequired[Nullable[List[StepEventActionsSubmitTypedDict]]]
+    r"""Actions to execute when the tool/step is submitted by the LLM."""
+
+
+class StepEventActions(BaseModel):
+    r"""Actions to perform when events occur (enter, submit)."""
+
+    start: OptionalNullable[List[StepEventActionsStart]] = UNSET
+    r"""Actions to execute on the first input from the user."""
+
+    enter: OptionalNullable[List[Enter]] = UNSET
+    r"""Actions to execute when entering a step (before collecting inputs)."""
+
+    submit: OptionalNullable[List[StepEventActionsSubmit]] = 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", "enter", "submit"]
+        nullable_fields = ["start", "enter", "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/stepstask.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 .step import Step, StepTypedDict
+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 StepsTaskTypedDict(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["steps"]
+    version: Literal["v1alpha"]
+    steps: NotRequired[List[StepTypedDict]]
+
+
+class StepsTask(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["steps"]], AfterValidator(validate_const("steps"))],
+        pydantic.Field(alias="type"),
+    ] = "steps"
+
+    VERSION: Annotated[
+        Annotated[
+            Optional[Literal["v1alpha"]], AfterValidator(validate_const("v1alpha"))
+        ],
+        pydantic.Field(alias="version"),
+    ] = "v1alpha"
+
+    steps: Optional[List[Step]] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "id",
+            "config",
+            "variables",
+            "metadata",
+            "tool",
+            "type",
+            "version",
+            "steps",
+        ]
+        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/steptools.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 List
+from typing_extensions import NotRequired, TypedDict
+
+
+class StepToolsTypedDict(TypedDict):
+    r"""Configuration for tools available in a step."""
+
+    call: NotRequired[Nullable[bool]]
+    r"""Whether to force immediate tool call without user interaction."""
+    allow: NotRequired[Nullable[List[str]]]
+    r"""List of allowed tool names for this step."""
+    allow_go_to_step: NotRequired[Nullable[bool]]
+    r"""Whether to expose the go_to_step escape hatch to the LLM. Defaults to disabled."""
+
+
+class StepTools(BaseModel):
+    r"""Configuration for tools available in a step."""
+
+    call: OptionalNullable[bool] = UNSET
+    r"""Whether to force immediate tool call without user interaction."""
+
+    allow: OptionalNullable[List[str]] = UNSET
+    r"""List of allowed tool names for this step."""
+
+    allow_go_to_step: OptionalNullable[bool] = UNSET
+    r"""Whether to expose the go_to_step escape hatch to the LLM. Defaults to disabled."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["call", "allow", "allow_go_to_step"]
+        nullable_fields = ["call", "allow", "allow_go_to_step"]
+        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/tooldefinition.py

@@ -1,6 +1,7 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .context import Context, ContextTypedDict
 from .internaltool import InternalTool, InternalToolTypedDict
 from .statictoolparameter import StaticToolParameter, StaticToolParameterTypedDict
 from .toolhttpendpoint import ToolHTTPEndpoint, ToolHTTPEndpointTypedDict
@@ -19,7 +20,7 @@ from typing import Any, Dict, List, Union
 from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
-class Type(str, Enum):
+class ToolDefinitionType(str, Enum):
     ACTION = "action"
     ENDPOINT = "endpoint"
     CONTEXT = "context"
@@ -41,10 +42,12 @@ class ToolDefinitionTypedDict(TypedDict):
 
     tool: InternalToolTypedDict
     r"""A tool definition to be used by the OpenAI API."""
-    type: NotRequired[Nullable[Type]]
+    type: NotRequired[Nullable[ToolDefinitionType]]
     r"""The action to take when the LLM calls the tool."""
     endpoint: NotRequired[Nullable[ToolHTTPEndpointTypedDict]]
     r"""The configuration for an HTTP API call."""
+    context: NotRequired[Nullable[ContextTypedDict]]
+    r"""The configuration for a context tool."""
     defaults: NotRequired[Nullable[DefaultsTypedDict]]
     r"""The default values for the parameters of the function/tool call."""
     static_parameters: NotRequired[Nullable[List[StaticToolParameterTypedDict]]]
@@ -61,12 +64,15 @@ class ToolDefinition(BaseModel):
     tool: InternalTool
     r"""A tool definition to be used by the OpenAI API."""
 
-    type: OptionalNullable[Type] = UNSET
+    type: OptionalNullable[ToolDefinitionType] = UNSET
     r"""The action to take when the LLM calls the tool."""
 
     endpoint: OptionalNullable[ToolHTTPEndpoint] = UNSET
     r"""The configuration for an HTTP API call."""
 
+    context: OptionalNullable[Context] = UNSET
+    r"""The configuration for a context tool."""
+
     defaults: OptionalNullable[Defaults] = UNSET
     r"""The default values for the parameters of the function/tool call."""
 
@@ -84,6 +90,7 @@ class ToolDefinition(BaseModel):
         optional_fields = [
             "type",
             "endpoint",
+            "context",
             "defaults",
             "static_parameters",
             "result",
@@ -92,6 +99,7 @@ class ToolDefinition(BaseModel):
         nullable_fields = [
             "type",
             "endpoint",
+            "context",
             "defaults",
             "static_parameters",
             "result",

syllable_sdk/models/variable.py

@@ -0,0 +1,149 @@
+"""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 syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator
+from typing import Any, List, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+VariableValueFrom1TypedDict = TypeAliasType(
+    "VariableValueFrom1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+VariableValueFrom1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+VariableValueFrom2TypedDict = TypeAliasType(
+    "VariableValueFrom2TypedDict",
+    Union[CaseExpressionTypedDict, VariableValueFrom1TypedDict, str],
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+VariableValueFrom2 = TypeAliasType(
+    "VariableValueFrom2", Union[CaseExpression, VariableValueFrom1, str]
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+class VariableType(str, Enum):
+    STRING = "string"
+    NUMBER = "number"
+    INTEGER = "integer"
+    BOOLEAN = "boolean"
+    OBJECT = "object"
+    ARRAY = "array"
+    NULL = "null"
+
+
+class VariableTypedDict(TypedDict):
+    name: str
+    r"""The name of the property."""
+    value: NotRequired[Nullable[Any]]
+    r"""Initial value of the variable."""
+    value_from: NotRequired[Nullable[VariableValueFrom2TypedDict]]
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+    type: NotRequired[Nullable[VariableType]]
+    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]]]
+
+
+class Variable(BaseModel):
+    name: str
+    r"""The name of the property."""
+
+    value: OptionalNullable[Any] = UNSET
+    r"""Initial value of the variable."""
+
+    value_from: OptionalNullable[VariableValueFrom2] = UNSET
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+
+    type: OptionalNullable[VariableType] = 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
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "value",
+            "value_from",
+            "type",
+            "description",
+            "title",
+            "format",
+            "pattern",
+            "enum",
+            "examples",
+        ]
+        nullable_fields = [
+            "value",
+            "value_from",
+            "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-0.41.20.dist-info → syllable_sdk-0.43.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syllable-sdk
-Version: 0.41.20
+Version: 0.43.1
 Summary: Python Client SDK Generated by Speakeasy.
 Author: Syllable
 Requires-Python: >=3.9.2