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

syllable_sdk/models/session.py

@@ -56,6 +56,8 @@ class SessionTypedDict(TypedDict):
     r"""Whether the session occurred on the legacy Syllable system"""
     is_test: NotRequired[Nullable[bool]]
     r"""Whether the session is a test session"""
+    user_terminated: NotRequired[Nullable[bool]]
+    r"""Whether the voice session was ended by the recipient (outbound) / caller (inbound). False if the user was transferred or there was an error. Unset if the session was not a voice session."""
 
 
 class Session(BaseModel):
@@ -121,6 +123,9 @@ class Session(BaseModel):
     is_test: OptionalNullable[bool] = UNSET
     r"""Whether the session is a test session"""
 
+    user_terminated: OptionalNullable[bool] = UNSET
+    r"""Whether the voice session was ended by the recipient (outbound) / caller (inbound). False if the user was transferred or there was an error. Unset if the session was not a voice session."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -143,6 +148,7 @@ class Session(BaseModel):
             "target",
             "is_legacy",
             "is_test",
+            "user_terminated",
         ]
         nullable_fields = [
             "session_id",
@@ -164,6 +170,7 @@ class Session(BaseModel):
             "target",
             "is_legacy",
             "is_test",
+            "user_terminated",
         ]
         null_default_fields = []
 

syllable_sdk/models/setvalueaction.py

@@ -0,0 +1,140 @@
+"""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, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+SetValueActionValueFrom1TypedDict = TypeAliasType(
+    "SetValueActionValueFrom1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+SetValueActionValueFrom1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+SetValueActionValueFrom2TypedDict = TypeAliasType(
+    "SetValueActionValueFrom2TypedDict",
+    Union[CaseExpressionTypedDict, SetValueActionValueFrom1TypedDict, str],
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+SetValueActionValueFrom2 = TypeAliasType(
+    "SetValueActionValueFrom2", Union[CaseExpression, SetValueActionValueFrom1, str]
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+SetValueActionIf1TypedDict = TypeAliasType(
+    "SetValueActionIf1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+SetValueActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+SetValueActionIf2TypedDict = TypeAliasType(
+    "SetValueActionIf2TypedDict",
+    Union[CaseExpressionTypedDict, SetValueActionIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+SetValueActionIf2 = TypeAliasType(
+    "SetValueActionIf2", Union[CaseExpression, SetValueActionIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class SetValueActionTypedDict(TypedDict):
+    name: str
+    r"""Destination path to mutate (e.g. output.foo)."""
+    value: NotRequired[Nullable[Any]]
+    r"""Initial value of the variable."""
+    value_from: NotRequired[Nullable[SetValueActionValueFrom2TypedDict]]
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+    if_: NotRequired[Nullable[SetValueActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: Literal["set"]
+
+
+class SetValueAction(BaseModel):
+    name: str
+    r"""Destination path to mutate (e.g. output.foo)."""
+
+    value: OptionalNullable[Any] = UNSET
+    r"""Initial value of the variable."""
+
+    value_from: OptionalNullable[SetValueActionValueFrom2] = UNSET
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+
+    if_: Annotated[OptionalNullable[SetValueActionIf2], pydantic.Field(alias="if")] = (
+        UNSET
+    )
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    ACTION: Annotated[
+        Annotated[Optional[Literal["set"]], AfterValidator(validate_const("set"))],
+        pydantic.Field(alias="action"),
+    ] = "set"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["value", "value_from", "if", "action"]
+        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

syllable_sdk/models/step.py

@@ -0,0 +1,65 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .conditionaltext import ConditionalText, ConditionalTextTypedDict
+from .inputparameter import InputParameter, InputParameterTypedDict
+from .nextstep import NextStep, NextStepTypedDict
+from .stepeventactions import StepEventActions, StepEventActionsTypedDict
+from .steptools import StepTools, StepToolsTypedDict
+from syllable_sdk.types import BaseModel
+from typing import List, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+InstructionTypedDict = TypeAliasType(
+    "InstructionTypedDict", Union[ConditionalTextTypedDict, str]
+)
+
+
+Instruction = TypeAliasType("Instruction", Union[ConditionalText, str])
+
+
+NextTypedDict = TypeAliasType("NextTypedDict", Union[NextStepTypedDict, str])
+
+
+Next = TypeAliasType("Next", Union[NextStep, str])
+
+
+class StepTypedDict(TypedDict):
+    id: str
+    r"""The unique identifier of the step."""
+    goal: str
+    r"""The goal of the step."""
+    instructions: NotRequired[List[InstructionTypedDict]]
+    r"""The instructions for the step."""
+    tools: NotRequired[StepToolsTypedDict]
+    r"""Configuration for tools available in a step."""
+    inputs: NotRequired[List[InputParameterTypedDict]]
+    r"""The inputs for the step."""
+    on: NotRequired[StepEventActionsTypedDict]
+    r"""Actions to perform when events occur (enter, presubmit, submit)."""
+    next: NotRequired[List[NextTypedDict]]
+    r"""The next steps to execute."""
+
+
+class Step(BaseModel):
+    id: str
+    r"""The unique identifier of the step."""
+
+    goal: str
+    r"""The goal of the step."""
+
+    instructions: Optional[List[Instruction]] = None
+    r"""The instructions for the step."""
+
+    tools: Optional[StepTools] = None
+    r"""Configuration for tools available in a step."""
+
+    inputs: Optional[List[InputParameter]] = None
+    r"""The inputs for the step."""
+
+    on: Optional[StepEventActions] = None
+    r"""Actions to perform when events occur (enter, presubmit, submit)."""
+
+    next: Optional[List[Next]] = None
+    r"""The next steps to execute."""

syllable_sdk/models/stepeventactions.py

@@ -0,0 +1,166 @@
+"""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")),
+]
+
+
+PresubmitTypedDict = TypeAliasType(
+    "PresubmitTypedDict",
+    Union[IncrementActionTypedDict, SaveActionTypedDict, SetValueActionTypedDict],
+)
+
+
+Presubmit = Annotated[
+    Union[
+        Annotated[IncrementAction, Tag("inc")],
+        Annotated[SaveAction, Tag("save")],
+        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, presubmit, 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)."""
+    presubmit: NotRequired[Nullable[List[PresubmitTypedDict]]]
+    r"""Actions to execute before validation (data-mutation only: set, inc, save). Use this to set default values for required fields that would otherwise fail validation."""
+    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, presubmit, 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)."""
+
+    presubmit: OptionalNullable[List[Presubmit]] = UNSET
+    r"""Actions to execute before validation (data-mutation only: set, inc, save). Use this to set default values for required fields that would otherwise fail validation."""
+
+    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", "presubmit", "submit"]
+        nullable_fields = ["start", "enter", "presubmit", "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",