diff --git a/generators/python-v2/dynamic-snippets/src/context/DynamicTypeLiteralMapper.ts b/generators/python-v2/dynamic-snippets/src/context/DynamicTypeLiteralMapper.ts index edc22337b6b..b84808843b3 100644 --- a/generators/python-v2/dynamic-snippets/src/context/DynamicTypeLiteralMapper.ts +++ b/generators/python-v2/dynamic-snippets/src/context/DynamicTypeLiteralMapper.ts @@ -271,7 +271,12 @@ export class DynamicTypeLiteralMapper { object_: named, value: discriminatedUnionTypeInstance.value }); - return [...baseFields, ...objectEntries]; + // Skip object entries that overlap with base fields to avoid + // duplicate keyword arguments (e.g. stream condition properties + // inherited via extends that are already pinned as literals). + const baseFieldNames = new Set(baseFields.map((f) => f.name)); + const filteredObjectEntries = objectEntries.filter((entry) => !baseFieldNames.has(entry.name)); + return [...baseFields, ...filteredObjectEntries]; } case "singleProperty": { try { diff --git a/generators/python-v2/sdk/src/wire-tests/WireTestGenerator.ts b/generators/python-v2/sdk/src/wire-tests/WireTestGenerator.ts index a880b0a78f1..501ead13302 100644 --- a/generators/python-v2/sdk/src/wire-tests/WireTestGenerator.ts +++ b/generators/python-v2/sdk/src/wire-tests/WireTestGenerator.ts @@ -368,22 +368,32 @@ export class WireTestGenerator { if (isErrorResponse) { // For streaming endpoints, we need to consume the iterator inside pytest.raises if (this.isStreamingEndpoint(endpoint)) { - statements.push( - python.codeBlock( - `with pytest.raises(ApiError):\n for _ in ${apiCallAst.toString()}:\n pass` - ) + const block = python.codeBlock( + `with pytest.raises(ApiError):\n for _ in ${apiCallAst.toString()}:\n pass` ); + // Preserve import references from the AST that are lost during toString() + for (const ref of apiCallAst.getReferences()) { + block.addReference(ref); + } + statements.push(block); } else { - statements.push( - python.codeBlock(`with pytest.raises(ApiError):\n ${apiCallAst.toString()}`) - ); + const block = python.codeBlock(`with pytest.raises(ApiError):\n ${apiCallAst.toString()}`); + for (const ref of apiCallAst.getReferences()) { + block.addReference(ref); + } + statements.push(block); } } else { // For streaming endpoints, wrap the call in a for loop to consume the iterator // This is necessary because streaming methods return lazy generators that don't // execute the HTTP request until iterated if (this.isStreamingEndpoint(endpoint)) { - statements.push(python.codeBlock(`for _ in ${apiCallAst.toString()}:`)); + const block = python.codeBlock(`for _ in ${apiCallAst.toString()}:`); + // Preserve import references from the AST that are lost during toString() + for (const ref of apiCallAst.getReferences()) { + block.addReference(ref); + } + statements.push(block); statements.push(python.codeBlock(" pass")); } else { statements.push(apiCallAst); diff --git a/generators/python/sdk/versions.yml b/generators/python/sdk/versions.yml index b57e157fd40..e59b6c326f4 100644 --- a/generators/python/sdk/versions.yml +++ b/generators/python/sdk/versions.yml @@ -1,5 +1,26 @@ # yaml-language-server: $schema=../../../fern-versions-yml.schema.json # For unreleased changes, use unreleased.yml +- version: 5.3.11 + changelogEntry: + - summary: | + Fix duplicate keyword arguments in generated code for discriminated union + request bodies with stream condition properties. When a union variant inherits + the stream condition field from a base schema via extends, the property was + emitted twice — once from the union's base properties and once from the + variant's extended properties — causing SyntaxError in generated Python code. + type: fix + - summary: | + Escape triple quotes in docstrings to prevent premature docstring termination + when OpenAPI descriptions contain Python code examples with triple-quoted strings. + type: fix + - summary: | + Fix mypy call-overload errors in exported client wrapper by mirroring the + base client's @overload signatures and using **kwargs pass-through, instead + of suppressing the error with a type: ignore comment. + type: fix + createdAt: "2026-04-10" + irVersion: 65 + - version: 5.3.10 changelogEntry: - summary: | diff --git a/generators/python/src/fern_python/codegen/ast/nodes/docstring/docstring.py b/generators/python/src/fern_python/codegen/ast/nodes/docstring/docstring.py index f9884344c8d..4d24eba5a09 100644 --- a/generators/python/src/fern_python/codegen/ast/nodes/docstring/docstring.py +++ b/generators/python/src/fern_python/codegen/ast/nodes/docstring/docstring.py @@ -8,11 +8,14 @@ def escape_docstring(text: str) -> str: """ - Escape backslashes in docstrings to avoid SyntaxWarning for invalid escape sequences. - This is needed when docstrings contain backslashes in source text (e.g., FOO\\_BAR) - that would otherwise produce invalid escape sequences. + Escape special characters in docstrings to avoid syntax errors. + - Backslashes are escaped to prevent invalid escape sequences (e.g., FOO\\_BAR). + - Triple quotes are escaped to prevent premature docstring termination when + descriptions contain code examples with triple-quoted strings. """ - return text.replace("\\", "\\\\") + result = text.replace("\\", "\\\\") + result = result.replace('"""', '\\"""') + return result class Docstring(CodeWriter): diff --git a/generators/python/src/fern_python/generators/pydantic_model/type_declaration_handler/discriminated_union/simple_discriminated_union_generator.py b/generators/python/src/fern_python/generators/pydantic_model/type_declaration_handler/discriminated_union/simple_discriminated_union_generator.py index 308e16a805b..362e86355c9 100644 --- a/generators/python/src/fern_python/generators/pydantic_model/type_declaration_handler/discriminated_union/simple_discriminated_union_generator.py +++ b/generators/python/src/fern_python/generators/pydantic_model/type_declaration_handler/discriminated_union/simple_discriminated_union_generator.py @@ -138,11 +138,15 @@ def generate(self) -> None: ) ] discriminant_wire_value = self._union.discriminant.wire_value + base_property_wire_values = {bp.name.wire_value for bp in self._union.base_properties} object_properties = self._context.get_all_properties_including_extensions(shape.type_id) for object_property in object_properties: # Skip properties that match the discriminant field to avoid duplicate fields if object_property.name.wire_value == discriminant_wire_value: continue + # Skip properties already declared in the union's base properties + if object_property.name.wire_value in base_property_wire_values: + continue self._all_referenced_types.append(object_property.value_type) same_properties_as_object_property_fields.append( FernAwarePydanticField( diff --git a/generators/python/src/fern_python/generators/sdk/client_generator/generated_root_client.py b/generators/python/src/fern_python/generators/sdk/client_generator/generated_root_client.py index db9fb7d4bab..b4efa65498c 100644 --- a/generators/python/src/fern_python/generators/sdk/client_generator/generated_root_client.py +++ b/generators/python/src/fern_python/generators/sdk/client_generator/generated_root_client.py @@ -12,6 +12,7 @@ class RootClient: class_reference: AST.ClassReference parameters: List[ConstructorParameter] init_parameters: Optional[List[ConstructorParameter]] = field(default=None) + constructor_overloads: Optional[List[AST.FunctionSignature]] = field(default=None) @dataclass diff --git a/generators/python/src/fern_python/generators/sdk/client_generator/root_client_generator.py b/generators/python/src/fern_python/generators/sdk/client_generator/root_client_generator.py index 009b33ee62d..1dae81ab9c7 100644 --- a/generators/python/src/fern_python/generators/sdk/client_generator/root_client_generator.py +++ b/generators/python/src/fern_python/generators/sdk/client_generator/root_client_generator.py @@ -184,6 +184,8 @@ def __init__( base_url_example_value=base_url_example_value, sync_init_parameters=self._get_constructor_parameters(is_async=False), async_init_parameters=self._get_constructor_parameters(is_async=True), + sync_constructor_overloads=self._get_constructor_overloads(is_async=False), + async_constructor_overloads=self._get_constructor_overloads(is_async=True), ) self._generated_root_client = root_client_builder.build() @@ -1650,6 +1652,8 @@ def __init__( base_url_example_value: Optional[AST.Expression] = None, sync_init_parameters: Optional[Sequence[ConstructorParameter]] = None, async_init_parameters: Optional[Sequence[ConstructorParameter]] = None, + sync_constructor_overloads: Optional[List[AST.FunctionSignature]] = None, + async_constructor_overloads: Optional[List[AST.FunctionSignature]] = None, ): self._module_path = module_path self._class_name = class_name @@ -1664,6 +1668,8 @@ def __init__( self._oauth_token_override = oauth_token_override self._use_kwargs_snippets = use_kwargs_snippets self._base_url_example_value = base_url_example_value + self._sync_constructor_overloads = sync_constructor_overloads + self._async_constructor_overloads = async_constructor_overloads def build(self) -> GeneratedRootClient: def create_class_reference(class_name: str) -> AST.ClassReference: @@ -1831,11 +1837,13 @@ def build_default_snippet_kwargs() -> List[typing.Tuple[str, AST.Expression]]: class_reference=async_class_reference, parameters=self._constructor_parameters, init_parameters=self._async_init_parameters, + constructor_overloads=self._async_constructor_overloads, ), sync_instantiations=sync_instantiations, sync_client=RootClient( class_reference=sync_class_reference, parameters=self._constructor_parameters, init_parameters=self._sync_init_parameters, + constructor_overloads=self._sync_constructor_overloads, ), ) diff --git a/generators/python/src/fern_python/generators/sdk/sdk_generator.py b/generators/python/src/fern_python/generators/sdk/sdk_generator.py index 7472c47929e..6eb6442883a 100644 --- a/generators/python/src/fern_python/generators/sdk/sdk_generator.py +++ b/generators/python/src/fern_python/generators/sdk/sdk_generator.py @@ -606,6 +606,23 @@ def _create_wrapper_class_declaration( ) -> AST.ClassDeclaration: params = root_client.init_parameters if root_client.init_parameters is not None else root_client.parameters + if root_client.constructor_overloads is not None: + # When the base class has overloaded __init__ (e.g. OAuth + token), + # mirror the overloads on the wrapper and use **kwargs pass-through + # so the call to super().__init__() satisfies mypy without type: ignore. + def write_kwargs_super_init(writer: AST.NodeWriter) -> None: + writer.write_line("super().__init__(**kwargs)") + + return AST.ClassDeclaration( + name=class_name, + extends=[base_class_ref], + constructor=AST.ClassConstructor( + signature=AST.FunctionSignature(include_kwargs=True), + body=AST.CodeWriter(write_kwargs_super_init), + overloads=root_client.constructor_overloads, + ), + ) + named_params = [ AST.NamedFunctionParameter( name=param.constructor_parameter_name, diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionFullResponse.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionFullResponse.json new file mode 100644 index 00000000000..ac943096439 --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionFullResponse.json @@ -0,0 +1,36 @@ +{ + "type": "object", + "properties": { + "answer": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ] + }, + "finishReason": { + "oneOf": [ + { + "$ref": "#/definitions/CompletionFullResponseFinishReason" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false, + "definitions": { + "CompletionFullResponseFinishReason": { + "type": "string", + "enum": [ + "complete", + "length", + "error" + ] + } + } +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionFullResponseFinishReason.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionFullResponseFinishReason.json new file mode 100644 index 00000000000..eb2a9b3ba59 --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionFullResponseFinishReason.json @@ -0,0 +1,9 @@ +{ + "type": "string", + "enum": [ + "complete", + "length", + "error" + ], + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionRequest.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionRequest.json new file mode 100644 index 00000000000..e08920e78e0 --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionRequest.json @@ -0,0 +1,23 @@ +{ + "type": "object", + "properties": { + "query": { + "type": "string" + }, + "stream": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + } + }, + "required": [ + "query" + ], + "additionalProperties": false, + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionStreamChunk.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionStreamChunk.json new file mode 100644 index 00000000000..e46a9dea1d3 --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__CompletionStreamChunk.json @@ -0,0 +1,27 @@ +{ + "type": "object", + "properties": { + "delta": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ] + }, + "tokens": { + "oneOf": [ + { + "type": "integer" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false, + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__NullableStreamRequest.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__NullableStreamRequest.json new file mode 100644 index 00000000000..e08920e78e0 --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__NullableStreamRequest.json @@ -0,0 +1,23 @@ +{ + "type": "object", + "properties": { + "query": { + "type": "string" + }, + "stream": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + } + }, + "required": [ + "query" + ], + "additionalProperties": false, + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__StreamXFernStreamingUnionRequest.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__StreamXFernStreamingUnionRequest.json new file mode 100644 index 00000000000..f9df25e215b --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__StreamXFernStreamingUnionRequest.json @@ -0,0 +1,96 @@ +{ + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": [ + "message", + "interrupt", + "compact" + ] + } + }, + "oneOf": [ + { + "properties": { + "type": { + "const": "message" + }, + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + }, + "message": { + "type": "string" + } + }, + "required": [ + "type", + "prompt", + "message" + ] + }, + { + "properties": { + "type": { + "const": "interrupt" + }, + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + } + }, + "required": [ + "type", + "prompt" + ] + }, + { + "properties": { + "type": { + "const": "compact" + }, + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + }, + "data": { + "type": "string" + } + }, + "required": [ + "type", + "prompt", + "data" + ] + } + ], + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__StreamXFernStreamingUnionStreamRequest.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__StreamXFernStreamingUnionStreamRequest.json new file mode 100644 index 00000000000..f9df25e215b --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__StreamXFernStreamingUnionStreamRequest.json @@ -0,0 +1,96 @@ +{ + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": [ + "message", + "interrupt", + "compact" + ] + } + }, + "oneOf": [ + { + "properties": { + "type": { + "const": "message" + }, + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + }, + "message": { + "type": "string" + } + }, + "required": [ + "type", + "prompt", + "message" + ] + }, + { + "properties": { + "type": { + "const": "interrupt" + }, + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + } + }, + "required": [ + "type", + "prompt" + ] + }, + { + "properties": { + "type": { + "const": "compact" + }, + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + }, + "data": { + "type": "string" + } + }, + "required": [ + "type", + "prompt", + "data" + ] + } + ], + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamCompactVariant.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamCompactVariant.json new file mode 100644 index 00000000000..ab994e5e05e --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamCompactVariant.json @@ -0,0 +1,27 @@ +{ + "type": "object", + "properties": { + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + }, + "data": { + "type": "string" + } + }, + "required": [ + "prompt", + "data" + ], + "additionalProperties": false, + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamInterruptVariant.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamInterruptVariant.json new file mode 100644 index 00000000000..f060a9c90fb --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamInterruptVariant.json @@ -0,0 +1,23 @@ +{ + "type": "object", + "properties": { + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + } + }, + "required": [ + "prompt" + ], + "additionalProperties": false, + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamMessageVariant.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamMessageVariant.json new file mode 100644 index 00000000000..71ea2115cab --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamMessageVariant.json @@ -0,0 +1,27 @@ +{ + "type": "object", + "properties": { + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + }, + "message": { + "type": "string" + } + }, + "required": [ + "prompt", + "message" + ], + "additionalProperties": false, + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamRequest.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamRequest.json new file mode 100644 index 00000000000..f9df25e215b --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamRequest.json @@ -0,0 +1,96 @@ +{ + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": [ + "message", + "interrupt", + "compact" + ] + } + }, + "oneOf": [ + { + "properties": { + "type": { + "const": "message" + }, + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + }, + "message": { + "type": "string" + } + }, + "required": [ + "type", + "prompt", + "message" + ] + }, + { + "properties": { + "type": { + "const": "interrupt" + }, + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + } + }, + "required": [ + "type", + "prompt" + ] + }, + { + "properties": { + "type": { + "const": "compact" + }, + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + }, + "data": { + "type": "string" + } + }, + "required": [ + "type", + "prompt", + "data" + ] + } + ], + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamRequestBase.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamRequestBase.json new file mode 100644 index 00000000000..f060a9c90fb --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__UnionStreamRequestBase.json @@ -0,0 +1,23 @@ +{ + "type": "object", + "properties": { + "stream_response": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + }, + "prompt": { + "type": "string" + } + }, + "required": [ + "prompt" + ], + "additionalProperties": false, + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__ValidateUnionRequestResponse.json b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__ValidateUnionRequestResponse.json new file mode 100644 index 00000000000..25a705c9d2a --- /dev/null +++ b/packages/cli/fern-definition/ir-to-jsonschema/src/__test__/__snapshots__/server-sent-events-openapi/type__ValidateUnionRequestResponse.json @@ -0,0 +1,17 @@ +{ + "type": "object", + "properties": { + "valid": { + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ] + } + }, + "additionalProperties": false, + "definitions": {} +} \ No newline at end of file diff --git a/packages/cli/generation/ir-generator-tests/src/dynamic-snippets/__test__/test-definitions/server-sent-events-openapi.json b/packages/cli/generation/ir-generator-tests/src/dynamic-snippets/__test__/test-definitions/server-sent-events-openapi.json index ad50ed696d2..56c6451bad7 100644 --- a/packages/cli/generation/ir-generator-tests/src/dynamic-snippets/__test__/test-definitions/server-sent-events-openapi.json +++ b/packages/cli/generation/ir-generator-tests/src/dynamic-snippets/__test__/test-definitions/server-sent-events-openapi.json @@ -805,6 +805,544 @@ } } }, + "type_:StreamXFernStreamingUnionStreamRequest": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingUnionStreamRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingUnionStreamRequest", + "safeName": "streamXFernStreamingUnionStreamRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_union_stream_request", + "safeName": "stream_x_fern_streaming_union_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_UNION_STREAM_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_UNION_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingUnionStreamRequest", + "safeName": "StreamXFernStreamingUnionStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "type", + "name": { + "originalName": "type", + "camelCase": { + "unsafeName": "type", + "safeName": "type" + }, + "snakeCase": { + "unsafeName": "type", + "safeName": "type" + }, + "screamingSnakeCase": { + "unsafeName": "TYPE", + "safeName": "TYPE" + }, + "pascalCase": { + "unsafeName": "Type", + "safeName": "Type" + } + } + }, + "types": { + "message": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "discriminantValue": { + "wireValue": "message", + "name": { + "originalName": "message", + "camelCase": { + "unsafeName": "message", + "safeName": "message" + }, + "snakeCase": { + "unsafeName": "message", + "safeName": "message" + }, + "screamingSnakeCase": { + "unsafeName": "MESSAGE", + "safeName": "MESSAGE" + }, + "pascalCase": { + "unsafeName": "Message", + "safeName": "Message" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "interrupt": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamInterruptVariant", + "discriminantValue": { + "wireValue": "interrupt", + "name": { + "originalName": "interrupt", + "camelCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "snakeCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "screamingSnakeCase": { + "unsafeName": "INTERRUPT", + "safeName": "INTERRUPT" + }, + "pascalCase": { + "unsafeName": "Interrupt", + "safeName": "Interrupt" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "compact": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamCompactVariant", + "discriminantValue": { + "wireValue": "compact", + "name": { + "originalName": "compact", + "camelCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "snakeCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "screamingSnakeCase": { + "unsafeName": "COMPACT", + "safeName": "COMPACT" + }, + "pascalCase": { + "unsafeName": "Compact", + "safeName": "Compact" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + } + } + }, + "type_:StreamXFernStreamingUnionRequest": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingUnionRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingUnionRequest", + "safeName": "streamXFernStreamingUnionRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_union_request", + "safeName": "stream_x_fern_streaming_union_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_UNION_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_UNION_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingUnionRequest", + "safeName": "StreamXFernStreamingUnionRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "type", + "name": { + "originalName": "type", + "camelCase": { + "unsafeName": "type", + "safeName": "type" + }, + "snakeCase": { + "unsafeName": "type", + "safeName": "type" + }, + "screamingSnakeCase": { + "unsafeName": "TYPE", + "safeName": "TYPE" + }, + "pascalCase": { + "unsafeName": "Type", + "safeName": "Type" + } + } + }, + "types": { + "message": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "discriminantValue": { + "wireValue": "message", + "name": { + "originalName": "message", + "camelCase": { + "unsafeName": "message", + "safeName": "message" + }, + "snakeCase": { + "unsafeName": "message", + "safeName": "message" + }, + "screamingSnakeCase": { + "unsafeName": "MESSAGE", + "safeName": "MESSAGE" + }, + "pascalCase": { + "unsafeName": "Message", + "safeName": "Message" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "interrupt": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamInterruptVariant", + "discriminantValue": { + "wireValue": "interrupt", + "name": { + "originalName": "interrupt", + "camelCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "snakeCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "screamingSnakeCase": { + "unsafeName": "INTERRUPT", + "safeName": "INTERRUPT" + }, + "pascalCase": { + "unsafeName": "Interrupt", + "safeName": "Interrupt" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "compact": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamCompactVariant", + "discriminantValue": { + "wireValue": "compact", + "name": { + "originalName": "compact", + "camelCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "snakeCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "screamingSnakeCase": { + "unsafeName": "COMPACT", + "safeName": "COMPACT" + }, + "pascalCase": { + "unsafeName": "Compact", + "safeName": "Compact" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + } + } + }, + "type_:ValidateUnionRequestResponse": { + "type": "object", + "declaration": { + "name": { + "originalName": "ValidateUnionRequestResponse", + "camelCase": { + "unsafeName": "validateUnionRequestResponse", + "safeName": "validateUnionRequestResponse" + }, + "snakeCase": { + "unsafeName": "validate_union_request_response", + "safeName": "validate_union_request_response" + }, + "screamingSnakeCase": { + "unsafeName": "VALIDATE_UNION_REQUEST_RESPONSE", + "safeName": "VALIDATE_UNION_REQUEST_RESPONSE" + }, + "pascalCase": { + "unsafeName": "ValidateUnionRequestResponse", + "safeName": "ValidateUnionRequestResponse" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "valid", + "name": { + "originalName": "valid", + "camelCase": { + "unsafeName": "valid", + "safeName": "valid" + }, + "snakeCase": { + "unsafeName": "valid", + "safeName": "valid" + }, + "screamingSnakeCase": { + "unsafeName": "VALID", + "safeName": "VALID" + }, + "pascalCase": { + "unsafeName": "Valid", + "safeName": "Valid" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, "type_:StreamRequest": { "type": "object", "declaration": { @@ -2051,30 +2589,27 @@ "type_:EntityEventPayload" ], "additionalProperties": false - } - }, - "headers": [], - "endpoints": { - "endpoint_.streamProtocolNoCollision": { - "auth": null, + }, + "type_:CompletionRequest": { + "type": "object", "declaration": { "name": { - "originalName": "streamProtocolNoCollision", + "originalName": "CompletionRequest", "camelCase": { - "unsafeName": "streamProtocolNoCollision", - "safeName": "streamProtocolNoCollision" + "unsafeName": "completionRequest", + "safeName": "completionRequest" }, "snakeCase": { - "unsafeName": "stream_protocol_no_collision", - "safeName": "stream_protocol_no_collision" + "unsafeName": "completion_request", + "safeName": "completion_request" }, "screamingSnakeCase": { - "unsafeName": "STREAM_PROTOCOL_NO_COLLISION", - "safeName": "STREAM_PROTOCOL_NO_COLLISION" + "unsafeName": "COMPLETION_REQUEST", + "safeName": "COMPLETION_REQUEST" }, "pascalCase": { - "unsafeName": "StreamProtocolNoCollision", - "safeName": "StreamProtocolNoCollision" + "unsafeName": "CompletionRequest", + "safeName": "CompletionRequest" } }, "fernFilepath": { @@ -2083,19 +2618,1837 @@ "file": null } }, - "location": { - "method": "POST", - "path": "/stream/protocol-no-collision" - }, - "request": { - "type": "body", + "properties": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:NullableStreamRequest": { + "type": "object", + "declaration": { + "name": { + "originalName": "NullableStreamRequest", + "camelCase": { + "unsafeName": "nullableStreamRequest", + "safeName": "nullableStreamRequest" + }, + "snakeCase": { + "unsafeName": "nullable_stream_request", + "safeName": "nullable_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "NULLABLE_STREAM_REQUEST", + "safeName": "NULLABLE_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "NullableStreamRequest", + "safeName": "NullableStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "nullable", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:CompletionFullResponseFinishReason": { + "type": "enum", + "declaration": { + "name": { + "originalName": "CompletionFullResponseFinishReason", + "camelCase": { + "unsafeName": "completionFullResponseFinishReason", + "safeName": "completionFullResponseFinishReason" + }, + "snakeCase": { + "unsafeName": "completion_full_response_finish_reason", + "safeName": "completion_full_response_finish_reason" + }, + "screamingSnakeCase": { + "unsafeName": "COMPLETION_FULL_RESPONSE_FINISH_REASON", + "safeName": "COMPLETION_FULL_RESPONSE_FINISH_REASON" + }, + "pascalCase": { + "unsafeName": "CompletionFullResponseFinishReason", + "safeName": "CompletionFullResponseFinishReason" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "values": [ + { + "wireValue": "complete", + "name": { + "originalName": "complete", + "camelCase": { + "unsafeName": "complete", + "safeName": "complete" + }, + "snakeCase": { + "unsafeName": "complete", + "safeName": "complete" + }, + "screamingSnakeCase": { + "unsafeName": "COMPLETE", + "safeName": "COMPLETE" + }, + "pascalCase": { + "unsafeName": "Complete", + "safeName": "Complete" + } + } + }, + { + "wireValue": "length", + "name": { + "originalName": "length", + "camelCase": { + "unsafeName": "length", + "safeName": "length" + }, + "snakeCase": { + "unsafeName": "length", + "safeName": "length" + }, + "screamingSnakeCase": { + "unsafeName": "LENGTH", + "safeName": "LENGTH" + }, + "pascalCase": { + "unsafeName": "Length", + "safeName": "Length" + } + } + }, + { + "wireValue": "error", + "name": { + "originalName": "error", + "camelCase": { + "unsafeName": "error", + "safeName": "error" + }, + "snakeCase": { + "unsafeName": "error", + "safeName": "error" + }, + "screamingSnakeCase": { + "unsafeName": "ERROR", + "safeName": "ERROR" + }, + "pascalCase": { + "unsafeName": "Error", + "safeName": "Error" + } + } + } + ] + }, + "type_:CompletionFullResponse": { + "type": "object", + "declaration": { + "name": { + "originalName": "CompletionFullResponse", + "camelCase": { + "unsafeName": "completionFullResponse", + "safeName": "completionFullResponse" + }, + "snakeCase": { + "unsafeName": "completion_full_response", + "safeName": "completion_full_response" + }, + "screamingSnakeCase": { + "unsafeName": "COMPLETION_FULL_RESPONSE", + "safeName": "COMPLETION_FULL_RESPONSE" + }, + "pascalCase": { + "unsafeName": "CompletionFullResponse", + "safeName": "CompletionFullResponse" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "answer", + "name": { + "originalName": "answer", + "camelCase": { + "unsafeName": "answer", + "safeName": "answer" + }, + "snakeCase": { + "unsafeName": "answer", + "safeName": "answer" + }, + "screamingSnakeCase": { + "unsafeName": "ANSWER", + "safeName": "ANSWER" + }, + "pascalCase": { + "unsafeName": "Answer", + "safeName": "Answer" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "STRING" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "finishReason", + "name": { + "originalName": "finishReason", + "camelCase": { + "unsafeName": "finishReason", + "safeName": "finishReason" + }, + "snakeCase": { + "unsafeName": "finish_reason", + "safeName": "finish_reason" + }, + "screamingSnakeCase": { + "unsafeName": "FINISH_REASON", + "safeName": "FINISH_REASON" + }, + "pascalCase": { + "unsafeName": "FinishReason", + "safeName": "FinishReason" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "named", + "value": "type_:CompletionFullResponseFinishReason" + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:CompletionStreamChunk": { + "type": "object", + "declaration": { + "name": { + "originalName": "CompletionStreamChunk", + "camelCase": { + "unsafeName": "completionStreamChunk", + "safeName": "completionStreamChunk" + }, + "snakeCase": { + "unsafeName": "completion_stream_chunk", + "safeName": "completion_stream_chunk" + }, + "screamingSnakeCase": { + "unsafeName": "COMPLETION_STREAM_CHUNK", + "safeName": "COMPLETION_STREAM_CHUNK" + }, + "pascalCase": { + "unsafeName": "CompletionStreamChunk", + "safeName": "CompletionStreamChunk" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "delta", + "name": { + "originalName": "delta", + "camelCase": { + "unsafeName": "delta", + "safeName": "delta" + }, + "snakeCase": { + "unsafeName": "delta", + "safeName": "delta" + }, + "screamingSnakeCase": { + "unsafeName": "DELTA", + "safeName": "DELTA" + }, + "pascalCase": { + "unsafeName": "Delta", + "safeName": "Delta" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "STRING" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "tokens", + "name": { + "originalName": "tokens", + "camelCase": { + "unsafeName": "tokens", + "safeName": "tokens" + }, + "snakeCase": { + "unsafeName": "tokens", + "safeName": "tokens" + }, + "screamingSnakeCase": { + "unsafeName": "TOKENS", + "safeName": "TOKENS" + }, + "pascalCase": { + "unsafeName": "Tokens", + "safeName": "Tokens" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "INTEGER" + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:UnionStreamRequestBase": { + "type": "object", + "declaration": { + "name": { + "originalName": "UnionStreamRequestBase", + "camelCase": { + "unsafeName": "unionStreamRequestBase", + "safeName": "unionStreamRequestBase" + }, + "snakeCase": { + "unsafeName": "union_stream_request_base", + "safeName": "union_stream_request_base" + }, + "screamingSnakeCase": { + "unsafeName": "UNION_STREAM_REQUEST_BASE", + "safeName": "UNION_STREAM_REQUEST_BASE" + }, + "pascalCase": { + "unsafeName": "UnionStreamRequestBase", + "safeName": "UnionStreamRequestBase" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:UnionStreamMessageVariant": { + "type": "object", + "declaration": { + "name": { + "originalName": "UnionStreamMessageVariant", + "camelCase": { + "unsafeName": "unionStreamMessageVariant", + "safeName": "unionStreamMessageVariant" + }, + "snakeCase": { + "unsafeName": "union_stream_message_variant", + "safeName": "union_stream_message_variant" + }, + "screamingSnakeCase": { + "unsafeName": "UNION_STREAM_MESSAGE_VARIANT", + "safeName": "UNION_STREAM_MESSAGE_VARIANT" + }, + "pascalCase": { + "unsafeName": "UnionStreamMessageVariant", + "safeName": "UnionStreamMessageVariant" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "message", + "name": { + "originalName": "message", + "camelCase": { + "unsafeName": "message", + "safeName": "message" + }, + "snakeCase": { + "unsafeName": "message", + "safeName": "message" + }, + "screamingSnakeCase": { + "unsafeName": "MESSAGE", + "safeName": "MESSAGE" + }, + "pascalCase": { + "unsafeName": "Message", + "safeName": "Message" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": [ + "type_:UnionStreamRequestBase" + ], + "additionalProperties": false + }, + "type_:UnionStreamInterruptVariant": { + "type": "object", + "declaration": { + "name": { + "originalName": "UnionStreamInterruptVariant", + "camelCase": { + "unsafeName": "unionStreamInterruptVariant", + "safeName": "unionStreamInterruptVariant" + }, + "snakeCase": { + "unsafeName": "union_stream_interrupt_variant", + "safeName": "union_stream_interrupt_variant" + }, + "screamingSnakeCase": { + "unsafeName": "UNION_STREAM_INTERRUPT_VARIANT", + "safeName": "UNION_STREAM_INTERRUPT_VARIANT" + }, + "pascalCase": { + "unsafeName": "UnionStreamInterruptVariant", + "safeName": "UnionStreamInterruptVariant" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": [ + "type_:UnionStreamRequestBase" + ], + "additionalProperties": false + }, + "type_:UnionStreamCompactVariant": { + "type": "object", + "declaration": { + "name": { + "originalName": "UnionStreamCompactVariant", + "camelCase": { + "unsafeName": "unionStreamCompactVariant", + "safeName": "unionStreamCompactVariant" + }, + "snakeCase": { + "unsafeName": "union_stream_compact_variant", + "safeName": "union_stream_compact_variant" + }, + "screamingSnakeCase": { + "unsafeName": "UNION_STREAM_COMPACT_VARIANT", + "safeName": "UNION_STREAM_COMPACT_VARIANT" + }, + "pascalCase": { + "unsafeName": "UnionStreamCompactVariant", + "safeName": "UnionStreamCompactVariant" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "data", + "name": { + "originalName": "data", + "camelCase": { + "unsafeName": "data", + "safeName": "data" + }, + "snakeCase": { + "unsafeName": "data", + "safeName": "data" + }, + "screamingSnakeCase": { + "unsafeName": "DATA", + "safeName": "DATA" + }, + "pascalCase": { + "unsafeName": "Data", + "safeName": "Data" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": [ + "type_:UnionStreamRequestBase" + ], + "additionalProperties": false + }, + "type_:UnionStreamRequest": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "UnionStreamRequest", + "camelCase": { + "unsafeName": "unionStreamRequest", + "safeName": "unionStreamRequest" + }, + "snakeCase": { + "unsafeName": "union_stream_request", + "safeName": "union_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "UNION_STREAM_REQUEST", + "safeName": "UNION_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "UnionStreamRequest", + "safeName": "UnionStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "type", + "name": { + "originalName": "type", + "camelCase": { + "unsafeName": "type", + "safeName": "type" + }, + "snakeCase": { + "unsafeName": "type", + "safeName": "type" + }, + "screamingSnakeCase": { + "unsafeName": "TYPE", + "safeName": "TYPE" + }, + "pascalCase": { + "unsafeName": "Type", + "safeName": "Type" + } + } + }, + "types": { + "message": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "discriminantValue": { + "wireValue": "message", + "name": { + "originalName": "message", + "camelCase": { + "unsafeName": "message", + "safeName": "message" + }, + "snakeCase": { + "unsafeName": "message", + "safeName": "message" + }, + "screamingSnakeCase": { + "unsafeName": "MESSAGE", + "safeName": "MESSAGE" + }, + "pascalCase": { + "unsafeName": "Message", + "safeName": "Message" + } + } + }, + "properties": [] + }, + "interrupt": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamInterruptVariant", + "discriminantValue": { + "wireValue": "interrupt", + "name": { + "originalName": "interrupt", + "camelCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "snakeCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "screamingSnakeCase": { + "unsafeName": "INTERRUPT", + "safeName": "INTERRUPT" + }, + "pascalCase": { + "unsafeName": "Interrupt", + "safeName": "Interrupt" + } + } + }, + "properties": [] + }, + "compact": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamCompactVariant", + "discriminantValue": { + "wireValue": "compact", + "name": { + "originalName": "compact", + "camelCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "snakeCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "screamingSnakeCase": { + "unsafeName": "COMPACT", + "safeName": "COMPACT" + }, + "pascalCase": { + "unsafeName": "Compact", + "safeName": "Compact" + } + } + }, + "properties": [] + } + } + } + }, + "headers": [], + "endpoints": { + "endpoint_.streamProtocolNoCollision": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamProtocolNoCollision", + "camelCase": { + "unsafeName": "streamProtocolNoCollision", + "safeName": "streamProtocolNoCollision" + }, + "snakeCase": { + "unsafeName": "stream_protocol_no_collision", + "safeName": "stream_protocol_no_collision" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_PROTOCOL_NO_COLLISION", + "safeName": "STREAM_PROTOCOL_NO_COLLISION" + }, + "pascalCase": { + "unsafeName": "StreamProtocolNoCollision", + "safeName": "StreamProtocolNoCollision" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/protocol-no-collision" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null + }, + "endpoint_.streamProtocolCollision": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamProtocolCollision", + "camelCase": { + "unsafeName": "streamProtocolCollision", + "safeName": "streamProtocolCollision" + }, + "snakeCase": { + "unsafeName": "stream_protocol_collision", + "safeName": "stream_protocol_collision" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_PROTOCOL_COLLISION", + "safeName": "STREAM_PROTOCOL_COLLISION" + }, + "pascalCase": { + "unsafeName": "StreamProtocolCollision", + "safeName": "StreamProtocolCollision" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/protocol-collision" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null + }, + "endpoint_.streamDataContext": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamDataContext", + "camelCase": { + "unsafeName": "streamDataContext", + "safeName": "streamDataContext" + }, + "snakeCase": { + "unsafeName": "stream_data_context", + "safeName": "stream_data_context" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_DATA_CONTEXT", + "safeName": "STREAM_DATA_CONTEXT" + }, + "pascalCase": { + "unsafeName": "StreamDataContext", + "safeName": "StreamDataContext" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/data-context" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null + }, + "endpoint_.streamNoContext": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamNoContext", + "camelCase": { + "unsafeName": "streamNoContext", + "safeName": "streamNoContext" + }, + "snakeCase": { + "unsafeName": "stream_no_context", + "safeName": "stream_no_context" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_NO_CONTEXT", + "safeName": "STREAM_NO_CONTEXT" + }, + "pascalCase": { + "unsafeName": "StreamNoContext", + "safeName": "StreamNoContext" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/no-context" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null + }, + "endpoint_.streamProtocolWithFlatSchema": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamProtocolWithFlatSchema", + "camelCase": { + "unsafeName": "streamProtocolWithFlatSchema", + "safeName": "streamProtocolWithFlatSchema" + }, + "snakeCase": { + "unsafeName": "stream_protocol_with_flat_schema", + "safeName": "stream_protocol_with_flat_schema" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA", + "safeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA" + }, + "pascalCase": { + "unsafeName": "StreamProtocolWithFlatSchema", + "safeName": "StreamProtocolWithFlatSchema" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/protocol-with-flat-schema" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null + }, + "endpoint_.streamDataContextWithEnvelopeSchema": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamDataContextWithEnvelopeSchema", + "camelCase": { + "unsafeName": "streamDataContextWithEnvelopeSchema", + "safeName": "streamDataContextWithEnvelopeSchema" + }, + "snakeCase": { + "unsafeName": "stream_data_context_with_envelope_schema", + "safeName": "stream_data_context_with_envelope_schema" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA", + "safeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA" + }, + "pascalCase": { + "unsafeName": "StreamDataContextWithEnvelopeSchema", + "safeName": "StreamDataContextWithEnvelopeSchema" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/data-context-with-envelope-schema" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null + }, + "endpoint_.streamOasSpecNative": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamOasSpecNative", + "camelCase": { + "unsafeName": "streamOasSpecNative", + "safeName": "streamOasSpecNative" + }, + "snakeCase": { + "unsafeName": "stream_oas_spec_native", + "safeName": "stream_oas_spec_native" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_OAS_SPEC_NATIVE", + "safeName": "STREAM_OAS_SPEC_NATIVE" + }, + "pascalCase": { + "unsafeName": "StreamOasSpecNative", + "safeName": "StreamOasSpecNative" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/oas-spec-native" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null + }, + "endpoint_.streamXFernStreamingCondition_stream": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamXFernStreamingCondition_stream", + "camelCase": { + "unsafeName": "streamXFernStreamingConditionStream", + "safeName": "streamXFernStreamingConditionStream" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_condition_stream", + "safeName": "stream_x_fern_streaming_condition_stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_CONDITION_STREAM", + "safeName": "STREAM_X_FERN_STREAMING_CONDITION_STREAM" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingConditionStream", + "safeName": "StreamXFernStreamingConditionStream" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/x-fern-streaming-condition" + }, + "request": { + "type": "inlined", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingConditionStreamRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingConditionStreamRequest", + "safeName": "streamXFernStreamingConditionStreamRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_condition_stream_request", + "safeName": "stream_x_fern_streaming_condition_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_CONDITION_STREAM_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_CONDITION_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingConditionStreamRequest", + "safeName": "StreamXFernStreamingConditionStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "pathParameters": [], + "queryParameters": [], + "headers": [], + "body": { + "type": "properties", + "value": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false + } + }, + "response": { + "type": "streaming" + }, + "examples": null + }, + "endpoint_.streamXFernStreamingCondition": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamXFernStreamingCondition", + "camelCase": { + "unsafeName": "streamXFernStreamingCondition", + "safeName": "streamXFernStreamingCondition" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_condition", + "safeName": "stream_x_fern_streaming_condition" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_CONDITION", + "safeName": "STREAM_X_FERN_STREAMING_CONDITION" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingCondition", + "safeName": "StreamXFernStreamingCondition" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/x-fern-streaming-condition" + }, + "request": { + "type": "inlined", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingConditionRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingConditionRequest", + "safeName": "streamXFernStreamingConditionRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_condition_request", + "safeName": "stream_x_fern_streaming_condition_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_CONDITION_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_CONDITION_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingConditionRequest", + "safeName": "StreamXFernStreamingConditionRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "pathParameters": [], + "queryParameters": [], + "headers": [], + "body": { + "type": "properties", + "value": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false + } + }, + "response": { + "type": "json" + }, + "examples": null + }, + "endpoint_.streamXFernStreamingSharedSchema_stream": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamXFernStreamingSharedSchema_stream", + "camelCase": { + "unsafeName": "streamXFernStreamingSharedSchemaStream", + "safeName": "streamXFernStreamingSharedSchemaStream" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_shared_schema_stream", + "safeName": "stream_x_fern_streaming_shared_schema_stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_STREAM", + "safeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_STREAM" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingSharedSchemaStream", + "safeName": "StreamXFernStreamingSharedSchemaStream" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/x-fern-streaming-shared-schema" + }, + "request": { + "type": "inlined", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingSharedSchemaStreamRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingSharedSchemaStreamRequest", + "safeName": "streamXFernStreamingSharedSchemaStreamRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_shared_schema_stream_request", + "safeName": "stream_x_fern_streaming_shared_schema_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_STREAM_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingSharedSchemaStreamRequest", + "safeName": "StreamXFernStreamingSharedSchemaStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, "pathParameters": [], + "queryParameters": [], + "headers": [], "body": { - "type": "typeReference", - "value": { - "type": "named", - "value": "type_:StreamRequest" - } + "type": "properties", + "value": [ + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "model", + "name": { + "originalName": "model", + "camelCase": { + "unsafeName": "model", + "safeName": "model" + }, + "snakeCase": { + "unsafeName": "model", + "safeName": "model" + }, + "screamingSnakeCase": { + "unsafeName": "MODEL", + "safeName": "MODEL" + }, + "pascalCase": { + "unsafeName": "Model", + "safeName": "Model" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } }, "response": { @@ -2103,26 +4456,26 @@ }, "examples": null }, - "endpoint_.streamProtocolCollision": { + "endpoint_.streamXFernStreamingSharedSchema": { "auth": null, "declaration": { "name": { - "originalName": "streamProtocolCollision", + "originalName": "streamXFernStreamingSharedSchema", "camelCase": { - "unsafeName": "streamProtocolCollision", - "safeName": "streamProtocolCollision" + "unsafeName": "streamXFernStreamingSharedSchema", + "safeName": "streamXFernStreamingSharedSchema" }, "snakeCase": { - "unsafeName": "stream_protocol_collision", - "safeName": "stream_protocol_collision" + "unsafeName": "stream_x_fern_streaming_shared_schema", + "safeName": "stream_x_fern_streaming_shared_schema" }, "screamingSnakeCase": { - "unsafeName": "STREAM_PROTOCOL_COLLISION", - "safeName": "STREAM_PROTOCOL_COLLISION" + "unsafeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA", + "safeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA" }, "pascalCase": { - "unsafeName": "StreamProtocolCollision", - "safeName": "StreamProtocolCollision" + "unsafeName": "StreamXFernStreamingSharedSchema", + "safeName": "StreamXFernStreamingSharedSchema" } }, "fernFilepath": { @@ -2133,44 +4486,338 @@ }, "location": { "method": "POST", - "path": "/stream/protocol-collision" + "path": "/stream/x-fern-streaming-shared-schema" }, "request": { - "type": "body", + "type": "inlined", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingSharedSchemaRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingSharedSchemaRequest", + "safeName": "streamXFernStreamingSharedSchemaRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_shared_schema_request", + "safeName": "stream_x_fern_streaming_shared_schema_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingSharedSchemaRequest", + "safeName": "StreamXFernStreamingSharedSchemaRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, "pathParameters": [], + "queryParameters": [], + "headers": [], "body": { - "type": "typeReference", - "value": { - "type": "named", - "value": "type_:StreamRequest" + "type": "properties", + "value": [ + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "model", + "name": { + "originalName": "model", + "camelCase": { + "unsafeName": "model", + "safeName": "model" + }, + "snakeCase": { + "unsafeName": "model", + "safeName": "model" + }, + "screamingSnakeCase": { + "unsafeName": "MODEL", + "safeName": "MODEL" + }, + "pascalCase": { + "unsafeName": "Model", + "safeName": "Model" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false + } + }, + "response": { + "type": "json" + }, + "examples": null + }, + "endpoint_.validateCompletion": { + "auth": null, + "declaration": { + "name": { + "originalName": "validateCompletion", + "camelCase": { + "unsafeName": "validateCompletion", + "safeName": "validateCompletion" + }, + "snakeCase": { + "unsafeName": "validate_completion", + "safeName": "validate_completion" + }, + "screamingSnakeCase": { + "unsafeName": "VALIDATE_COMPLETION", + "safeName": "VALIDATE_COMPLETION" + }, + "pascalCase": { + "unsafeName": "ValidateCompletion", + "safeName": "ValidateCompletion" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/validate-completion" + }, + "request": { + "type": "inlined", + "declaration": { + "name": { + "originalName": "SharedCompletionRequest", + "camelCase": { + "unsafeName": "sharedCompletionRequest", + "safeName": "sharedCompletionRequest" + }, + "snakeCase": { + "unsafeName": "shared_completion_request", + "safeName": "shared_completion_request" + }, + "screamingSnakeCase": { + "unsafeName": "SHARED_COMPLETION_REQUEST", + "safeName": "SHARED_COMPLETION_REQUEST" + }, + "pascalCase": { + "unsafeName": "SharedCompletionRequest", + "safeName": "SharedCompletionRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null } + }, + "pathParameters": [], + "queryParameters": [], + "headers": [], + "body": { + "type": "properties", + "value": [ + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "model", + "name": { + "originalName": "model", + "camelCase": { + "unsafeName": "model", + "safeName": "model" + }, + "snakeCase": { + "unsafeName": "model", + "safeName": "model" + }, + "screamingSnakeCase": { + "unsafeName": "MODEL", + "safeName": "MODEL" + }, + "pascalCase": { + "unsafeName": "Model", + "safeName": "Model" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } }, "response": { - "type": "streaming" + "type": "json" }, "examples": null }, - "endpoint_.streamDataContext": { + "endpoint_.streamXFernStreamingUnion_stream": { "auth": null, "declaration": { "name": { - "originalName": "streamDataContext", + "originalName": "streamXFernStreamingUnion_stream", "camelCase": { - "unsafeName": "streamDataContext", - "safeName": "streamDataContext" + "unsafeName": "streamXFernStreamingUnionStream", + "safeName": "streamXFernStreamingUnionStream" }, "snakeCase": { - "unsafeName": "stream_data_context", - "safeName": "stream_data_context" + "unsafeName": "stream_x_fern_streaming_union_stream", + "safeName": "stream_x_fern_streaming_union_stream" }, "screamingSnakeCase": { - "unsafeName": "STREAM_DATA_CONTEXT", - "safeName": "STREAM_DATA_CONTEXT" + "unsafeName": "STREAM_X_FERN_STREAMING_UNION_STREAM", + "safeName": "STREAM_X_FERN_STREAMING_UNION_STREAM" }, "pascalCase": { - "unsafeName": "StreamDataContext", - "safeName": "StreamDataContext" + "unsafeName": "StreamXFernStreamingUnionStream", + "safeName": "StreamXFernStreamingUnionStream" } }, "fernFilepath": { @@ -2181,7 +4828,7 @@ }, "location": { "method": "POST", - "path": "/stream/data-context" + "path": "/stream/x-fern-streaming-union" }, "request": { "type": "body", @@ -2190,7 +4837,7 @@ "type": "typeReference", "value": { "type": "named", - "value": "type_:StreamRequest" + "value": "type_:StreamXFernStreamingUnionStreamRequest" } } }, @@ -2199,26 +4846,26 @@ }, "examples": null }, - "endpoint_.streamNoContext": { + "endpoint_.streamXFernStreamingUnion": { "auth": null, "declaration": { "name": { - "originalName": "streamNoContext", + "originalName": "streamXFernStreamingUnion", "camelCase": { - "unsafeName": "streamNoContext", - "safeName": "streamNoContext" + "unsafeName": "streamXFernStreamingUnion", + "safeName": "streamXFernStreamingUnion" }, "snakeCase": { - "unsafeName": "stream_no_context", - "safeName": "stream_no_context" + "unsafeName": "stream_x_fern_streaming_union", + "safeName": "stream_x_fern_streaming_union" }, "screamingSnakeCase": { - "unsafeName": "STREAM_NO_CONTEXT", - "safeName": "STREAM_NO_CONTEXT" + "unsafeName": "STREAM_X_FERN_STREAMING_UNION", + "safeName": "STREAM_X_FERN_STREAMING_UNION" }, "pascalCase": { - "unsafeName": "StreamNoContext", - "safeName": "StreamNoContext" + "unsafeName": "StreamXFernStreamingUnion", + "safeName": "StreamXFernStreamingUnion" } }, "fernFilepath": { @@ -2229,7 +4876,7 @@ }, "location": { "method": "POST", - "path": "/stream/no-context" + "path": "/stream/x-fern-streaming-union" }, "request": { "type": "body", @@ -2238,35 +4885,35 @@ "type": "typeReference", "value": { "type": "named", - "value": "type_:StreamRequest" + "value": "type_:StreamXFernStreamingUnionRequest" } } }, "response": { - "type": "streaming" + "type": "json" }, "examples": null }, - "endpoint_.streamProtocolWithFlatSchema": { + "endpoint_.validateUnionRequest": { "auth": null, "declaration": { "name": { - "originalName": "streamProtocolWithFlatSchema", + "originalName": "validateUnionRequest", "camelCase": { - "unsafeName": "streamProtocolWithFlatSchema", - "safeName": "streamProtocolWithFlatSchema" + "unsafeName": "validateUnionRequest", + "safeName": "validateUnionRequest" }, "snakeCase": { - "unsafeName": "stream_protocol_with_flat_schema", - "safeName": "stream_protocol_with_flat_schema" + "unsafeName": "validate_union_request", + "safeName": "validate_union_request" }, "screamingSnakeCase": { - "unsafeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA", - "safeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA" + "unsafeName": "VALIDATE_UNION_REQUEST", + "safeName": "VALIDATE_UNION_REQUEST" }, "pascalCase": { - "unsafeName": "StreamProtocolWithFlatSchema", - "safeName": "StreamProtocolWithFlatSchema" + "unsafeName": "ValidateUnionRequest", + "safeName": "ValidateUnionRequest" } }, "fernFilepath": { @@ -2277,7 +4924,7 @@ }, "location": { "method": "POST", - "path": "/stream/protocol-with-flat-schema" + "path": "/validate-union-request" }, "request": { "type": "body", @@ -2286,35 +4933,35 @@ "type": "typeReference", "value": { "type": "named", - "value": "type_:StreamRequest" + "value": "type_:UnionStreamRequestBase" } } }, "response": { - "type": "streaming" + "type": "json" }, "examples": null }, - "endpoint_.streamDataContextWithEnvelopeSchema": { + "endpoint_.streamXFernStreamingNullableCondition_stream": { "auth": null, "declaration": { "name": { - "originalName": "streamDataContextWithEnvelopeSchema", + "originalName": "streamXFernStreamingNullableCondition_stream", "camelCase": { - "unsafeName": "streamDataContextWithEnvelopeSchema", - "safeName": "streamDataContextWithEnvelopeSchema" + "unsafeName": "streamXFernStreamingNullableConditionStream", + "safeName": "streamXFernStreamingNullableConditionStream" }, "snakeCase": { - "unsafeName": "stream_data_context_with_envelope_schema", - "safeName": "stream_data_context_with_envelope_schema" + "unsafeName": "stream_x_fern_streaming_nullable_condition_stream", + "safeName": "stream_x_fern_streaming_nullable_condition_stream" }, "screamingSnakeCase": { - "unsafeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA", - "safeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA" + "unsafeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_STREAM", + "safeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_STREAM" }, "pascalCase": { - "unsafeName": "StreamDataContextWithEnvelopeSchema", - "safeName": "StreamDataContextWithEnvelopeSchema" + "unsafeName": "StreamXFernStreamingNullableConditionStream", + "safeName": "StreamXFernStreamingNullableConditionStream" } }, "fernFilepath": { @@ -2325,17 +4972,110 @@ }, "location": { "method": "POST", - "path": "/stream/data-context-with-envelope-schema" + "path": "/stream/x-fern-streaming-nullable-condition" }, "request": { - "type": "body", + "type": "inlined", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingNullableConditionStreamRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingNullableConditionStreamRequest", + "safeName": "streamXFernStreamingNullableConditionStreamRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_nullable_condition_stream_request", + "safeName": "stream_x_fern_streaming_nullable_condition_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_STREAM_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingNullableConditionStreamRequest", + "safeName": "StreamXFernStreamingNullableConditionStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, "pathParameters": [], + "queryParameters": [], + "headers": [], "body": { - "type": "typeReference", - "value": { - "type": "named", - "value": "type_:StreamRequest" - } + "type": "properties", + "value": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } }, "response": { @@ -2343,26 +5083,26 @@ }, "examples": null }, - "endpoint_.streamOasSpecNative": { + "endpoint_.streamXFernStreamingNullableCondition": { "auth": null, "declaration": { "name": { - "originalName": "streamOasSpecNative", + "originalName": "streamXFernStreamingNullableCondition", "camelCase": { - "unsafeName": "streamOasSpecNative", - "safeName": "streamOasSpecNative" + "unsafeName": "streamXFernStreamingNullableCondition", + "safeName": "streamXFernStreamingNullableCondition" }, "snakeCase": { - "unsafeName": "stream_oas_spec_native", - "safeName": "stream_oas_spec_native" + "unsafeName": "stream_x_fern_streaming_nullable_condition", + "safeName": "stream_x_fern_streaming_nullable_condition" }, "screamingSnakeCase": { - "unsafeName": "STREAM_OAS_SPEC_NATIVE", - "safeName": "STREAM_OAS_SPEC_NATIVE" + "unsafeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION", + "safeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION" }, "pascalCase": { - "unsafeName": "StreamOasSpecNative", - "safeName": "StreamOasSpecNative" + "unsafeName": "StreamXFernStreamingNullableCondition", + "safeName": "StreamXFernStreamingNullableCondition" } }, "fernFilepath": { @@ -2373,7 +5113,148 @@ }, "location": { "method": "POST", - "path": "/stream/oas-spec-native" + "path": "/stream/x-fern-streaming-nullable-condition" + }, + "request": { + "type": "inlined", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingNullableConditionRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingNullableConditionRequest", + "safeName": "streamXFernStreamingNullableConditionRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_nullable_condition_request", + "safeName": "stream_x_fern_streaming_nullable_condition_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingNullableConditionRequest", + "safeName": "StreamXFernStreamingNullableConditionRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "pathParameters": [], + "queryParameters": [], + "headers": [], + "body": { + "type": "properties", + "value": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false + } + }, + "response": { + "type": "json" + }, + "examples": null + }, + "endpoint_.streamXFernStreamingSseOnly": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamXFernStreamingSseOnly", + "camelCase": { + "unsafeName": "streamXFernStreamingSseOnly", + "safeName": "streamXFernStreamingSseOnly" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_sse_only", + "safeName": "stream_x_fern_streaming_sse_only" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_SSE_ONLY", + "safeName": "STREAM_X_FERN_STREAMING_SSE_ONLY" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingSseOnly", + "safeName": "StreamXFernStreamingSseOnly" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "location": { + "method": "POST", + "path": "/stream/x-fern-streaming-sse-only" }, "request": { "type": "body", diff --git a/packages/cli/generation/ir-generator-tests/src/ir/__test__/test-definitions/server-sent-events-openapi.json b/packages/cli/generation/ir-generator-tests/src/ir/__test__/test-definitions/server-sent-events-openapi.json index 9bcd3342fe4..d652bf3ee81 100644 --- a/packages/cli/generation/ir-generator-tests/src/ir/__test__/test-definitions/server-sent-events-openapi.json +++ b/packages/cli/generation/ir-generator-tests/src/ir/__test__/test-definitions/server-sent-events-openapi.json @@ -559,6 +559,286 @@ "availability": null, "docs": null }, + "type_:StreamXFernStreamingUnionStreamRequest": { + "inline": null, + "name": { + "name": "StreamXFernStreamingUnionStreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamXFernStreamingUnionStreamRequest" + }, + "shape": { + "_type": "union", + "discriminant": "type", + "extends": [], + "baseProperties": [ + { + "name": "stream_response", + "valueType": { + "_type": "container", + "container": { + "_type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": null + } + ], + "types": [ + { + "discriminantValue": "message", + "shape": { + "_type": "samePropertiesAsObject", + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "displayName": null, + "availability": null, + "docs": null + }, + { + "discriminantValue": "interrupt", + "shape": { + "_type": "samePropertiesAsObject", + "name": "UnionStreamInterruptVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamInterruptVariant" + }, + "displayName": null, + "availability": null, + "docs": null + }, + { + "discriminantValue": "compact", + "shape": { + "_type": "samePropertiesAsObject", + "name": "UnionStreamCompactVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamCompactVariant" + }, + "displayName": null, + "availability": null, + "docs": null + } + ], + "default": null, + "discriminatorContext": "data" + }, + "referencedTypes": [ + "type_:UnionStreamMessageVariant", + "type_:UnionStreamRequestBase", + "type_:UnionStreamInterruptVariant", + "type_:UnionStreamCompactVariant" + ], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict." + }, + "type_:StreamXFernStreamingUnionRequest": { + "inline": null, + "name": { + "name": "StreamXFernStreamingUnionRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamXFernStreamingUnionRequest" + }, + "shape": { + "_type": "union", + "discriminant": "type", + "extends": [], + "baseProperties": [ + { + "name": "stream_response", + "valueType": { + "_type": "container", + "container": { + "_type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": null + } + ], + "types": [ + { + "discriminantValue": "message", + "shape": { + "_type": "samePropertiesAsObject", + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "displayName": null, + "availability": null, + "docs": null + }, + { + "discriminantValue": "interrupt", + "shape": { + "_type": "samePropertiesAsObject", + "name": "UnionStreamInterruptVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamInterruptVariant" + }, + "displayName": null, + "availability": null, + "docs": null + }, + { + "discriminantValue": "compact", + "shape": { + "_type": "samePropertiesAsObject", + "name": "UnionStreamCompactVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamCompactVariant" + }, + "displayName": null, + "availability": null, + "docs": null + } + ], + "default": null, + "discriminatorContext": "data" + }, + "referencedTypes": [ + "type_:UnionStreamMessageVariant", + "type_:UnionStreamRequestBase", + "type_:UnionStreamInterruptVariant", + "type_:UnionStreamCompactVariant" + ], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict." + }, + "type_:ValidateUnionRequestResponse": { + "inline": null, + "name": { + "name": "ValidateUnionRequestResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:ValidateUnionRequestResponse" + }, + "shape": { + "_type": "object", + "extends": [], + "properties": [ + { + "name": "valid", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": null + } + } + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": null + } + ], + "extra-properties": false, + "extendedProperties": [] + }, + "referencedTypes": [], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": null + }, "type_:StreamRequest": { "inline": null, "name": { @@ -1585,764 +1865,1013 @@ "v2Examples": null, "availability": null, "docs": null - } - }, - "errors": {}, - "services": { - "service_": { - "availability": null, + }, + "type_:CompletionRequest": { + "inline": null, "name": { + "name": "CompletionRequest", "fernFilepath": { "allParts": [], "packagePath": [], "file": null - } - }, - "displayName": null, - "basePath": { - "head": "", - "parts": [] - }, - "headers": [], - "pathParameters": [], - "encoding": { - "json": {}, - "proto": null - }, - "transport": { - "type": "http" + }, + "displayName": null, + "typeId": "type_:CompletionRequest" }, - "endpoints": [ - { - "id": "endpoint_.streamProtocolNoCollision", - "name": "streamProtocolNoCollision", - "displayName": "Protocol context with no field collision and mixed data types", - "auth": false, - "security": null, - "idempotent": false, - "baseUrl": null, - "v2BaseUrls": null, - "method": "POST", - "basePath": null, - "path": { - "head": "/stream/protocol-no-collision", - "parts": [] + "shape": { + "_type": "object", + "extends": [], + "properties": [ + { + "name": "query", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "The prompt or query to complete." }, - "fullPath": { - "head": "stream/protocol-no-collision", - "parts": [] + { + "name": "stream", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": false + } + } + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "Whether to stream the response." + } + ], + "extra-properties": false, + "extendedProperties": [] + }, + "referencedTypes": [], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": null + }, + "type_:NullableStreamRequest": { + "inline": null, + "name": { + "name": "NullableStreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:NullableStreamRequest" + }, + "shape": { + "_type": "object", + "extends": [], + "properties": [ + { + "name": "query", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "The prompt or query to complete." }, - "pathParameters": [], - "allPathParameters": [], - "queryParameters": [], - "headers": [], - "requestBody": { - "type": "reference", - "requestBodyType": { - "_type": "named", - "name": "StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamRequest", - "default": null, - "inline": null + { + "name": "stream", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "container", + "container": { + "_type": "nullable", + "nullable": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": false + } + } + } + } + } + } }, - "docs": null, - "contentType": "application/json", - "v2Examples": null + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "Whether to stream the response. This field is nullable (OAS 3.1 type array), which previously caused the const literal to be overwritten by the nullable type during spread in the importer." + } + ], + "extra-properties": false, + "extendedProperties": [] + }, + "referencedTypes": [], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": null + }, + "type_:CompletionFullResponseFinishReason": { + "inline": true, + "name": { + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason" + }, + "shape": { + "_type": "enum", + "default": null, + "values": [ + { + "name": "complete", + "availability": null, + "docs": null }, - "v2RequestBodies": null, - "sdkRequest": { - "shape": { - "type": "justRequestBody", - "value": { - "type": "typeReference", - "requestBodyType": { + { + "name": "length", + "availability": null, + "docs": null + }, + { + "name": "error", + "availability": null, + "docs": null + } + ], + "forwardCompatible": null + }, + "referencedTypes": [], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "Why generation stopped." + }, + "type_:CompletionFullResponse": { + "inline": null, + "name": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "shape": { + "_type": "object", + "extends": [], + "properties": [ + { + "name": "answer", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "The complete generated answer." + }, + { + "name": "finishReason", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { "_type": "named", - "name": "StreamRequest", + "name": "CompletionFullResponseFinishReason", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:StreamRequest", + "typeId": "type_:CompletionFullResponseFinishReason", "default": null, "inline": null - }, - "docs": null, - "contentType": null, - "v2Examples": null + } } }, - "requestParameterName": "request", - "streamParameter": null - }, - "response": { - "body": { - "type": "streaming", - "value": { - "type": "sse", - "payload": { - "_type": "named", - "name": "StreamProtocolNoCollisionResponse", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamProtocolNoCollisionResponse", - "default": null, - "inline": null - }, - "terminator": null, - "docs": "SSE stream with protocol-level discrimination and mixed data types", - "v2Examples": null + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "Why generation stopped." + } + ], + "extra-properties": false, + "extendedProperties": [] + }, + "referencedTypes": [ + "type_:CompletionFullResponseFinishReason" + ], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "Full response returned when streaming is disabled." + }, + "type_:CompletionStreamChunk": { + "inline": null, + "name": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + }, + "shape": { + "_type": "object", + "extends": [], + "properties": [ + { + "name": "delta", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } } }, - "status-code": null, - "isWildcardStatusCode": null, - "docs": null + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "The incremental text chunk." }, - "v2Responses": null, - "errors": [], - "userSpecifiedExamples": [ - { - "example": { - "id": "bdd594d5", - "name": null, - "url": "/stream/protocol-no-collision", - "rootPathParameters": [], - "endpointPathParameters": [], - "servicePathParameters": [], - "endpointHeaders": [], - "serviceHeaders": [], - "queryParameters": [], - "request": { - "type": "reference", - "shape": { - "type": "named", - "typeName": { - "typeId": "type_:StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "name": "StreamRequest", - "displayName": null - }, - "shape": { - "type": "object", - "properties": [], - "extraProperties": null + { + "name": "tokens", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null } - }, - "jsonExample": {} - }, - "response": { - "type": "ok", - "value": { - "type": "sse", - "value": [ - { - "event": "", - "data": { - "shape": { - "type": "named", - "typeName": { - "typeId": "type_:StreamProtocolNoCollisionResponse", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "name": "StreamProtocolNoCollisionResponse", - "displayName": null - }, - "shape": { - "type": "union", - "discriminant": "event", - "singleUnionType": { - "wireDiscriminantValue": "heartbeat", - "shape": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolHeartbeat", - "object": { - "properties": [], - "extraProperties": null - } - } - }, - "baseProperties": [], - "extendProperties": [] - } - }, - "jsonExample": { - "event": "heartbeat" - } - } - } - ] } - }, - "docs": null - }, - "codeSamples": null - } - ], - "autogeneratedExamples": [ - { - "example": { - "id": "c58dfb6", - "url": "/stream/protocol-no-collision", - "name": null, - "endpointHeaders": [], - "endpointPathParameters": [], - "queryParameters": [], - "servicePathParameters": [], - "serviceHeaders": [], - "rootPathParameters": [], - "request": { - "type": "reference", - "shape": { - "type": "named", - "shape": { - "type": "object", - "properties": [ - { - "name": "query", - "originalTypeDeclaration": { - "name": "StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamRequest" - }, - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": null, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "STRING", - "v2": { - "type": "string", - "default": null, - "validation": null - } - } - } - } - } - }, - "propertyAccess": null - } - ], - "extraProperties": null - }, - "typeName": { - "name": "StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamRequest" - } - }, - "jsonExample": {} - }, - "response": { - "type": "ok", - "value": { - "type": "sse", - "value": [ - { - "data": { - "shape": { - "type": "named", - "shape": { - "type": "union", - "discriminant": "event", - "singleUnionType": { - "wireDiscriminantValue": "heartbeat", - "shape": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolHeartbeat", - "object": { - "properties": [], - "extraProperties": null - } - } - }, - "baseProperties": [], - "extendProperties": [] - }, - "typeName": { - "name": "StreamProtocolNoCollisionResponse", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamProtocolNoCollisionResponse" - } - }, - "jsonExample": { - "event": "heartbeat" - } - }, - "event": "heartbeat" - } - ] - } - }, - "docs": null + } } - } - ], - "pagination": null, - "transport": null, - "v2Examples": null, - "source": null, - "audiences": null, - "retries": null, - "apiPlayground": null, - "responseHeaders": [], - "availability": null, - "docs": "Uses discriminator with mapping, x-fern-discriminator-context set to protocol. Because the discriminant is at the protocol level, the data field can be any type or absent entirely. Demonstrates heartbeat (no data), string literal, number literal, and object data payloads." - }, - { - "id": "endpoint_.streamProtocolCollision", - "name": "streamProtocolCollision", - "displayName": "Protocol context with event field collision and mixed data types", - "auth": false, - "security": null, - "idempotent": false, - "baseUrl": null, - "v2BaseUrls": null, - "method": "POST", - "basePath": null, - "path": { - "head": "/stream/protocol-collision", - "parts": [] - }, - "fullPath": { - "head": "stream/protocol-collision", - "parts": [] - }, - "pathParameters": [], - "allPathParameters": [], - "queryParameters": [], - "headers": [], - "requestBody": { - "type": "reference", - "requestBodyType": { - "_type": "named", - "name": "StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamRequest", - "default": null, - "inline": null }, - "docs": null, - "contentType": "application/json", - "v2Examples": null - }, - "v2RequestBodies": null, - "sdkRequest": { - "shape": { - "type": "justRequestBody", - "value": { - "type": "typeReference", - "requestBodyType": { - "_type": "named", - "name": "StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamRequest", - "default": null, - "inline": null - }, - "docs": null, - "contentType": null, - "v2Examples": null + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "Number of tokens in this chunk." + } + ], + "extra-properties": false, + "extendedProperties": [] + }, + "referencedTypes": [], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "A single chunk in a streamed completion response." + }, + "type_:UnionStreamRequestBase": { + "inline": null, + "name": { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + }, + "shape": { + "_type": "object", + "extends": [], + "properties": [ + { + "name": "stream_response", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": false + } + } + } } }, - "requestParameterName": "request", - "streamParameter": null + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "Whether to stream the response." }, - "response": { - "body": { - "type": "streaming", - "value": { - "type": "sse", - "payload": { - "_type": "named", - "name": "StreamProtocolCollisionResponse", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamProtocolCollisionResponse", + { + "name": "prompt", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", "default": null, - "inline": null - }, - "terminator": null, - "docs": "SSE stream with protocol context and event field collision", - "v2Examples": null + "validation": null + } } }, - "status-code": null, - "isWildcardStatusCode": null, - "docs": null - }, - "v2Responses": null, - "errors": [], - "userSpecifiedExamples": [ - { - "example": { - "id": "bdd594d5", - "name": null, - "url": "/stream/protocol-collision", - "rootPathParameters": [], - "endpointPathParameters": [], - "servicePathParameters": [], - "endpointHeaders": [], - "serviceHeaders": [], - "queryParameters": [], - "request": { - "type": "reference", - "shape": { - "type": "named", - "typeName": { - "typeId": "type_:StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "name": "StreamRequest", - "displayName": null - }, - "shape": { - "type": "object", - "properties": [], - "extraProperties": null - } - }, - "jsonExample": {} - }, - "response": { - "type": "ok", - "value": { - "type": "sse", - "value": [ - { - "event": "", - "data": { - "shape": { - "type": "named", - "typeName": { - "typeId": "type_:StreamProtocolCollisionResponse", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "name": "StreamProtocolCollisionResponse", - "displayName": null - }, - "shape": { - "type": "union", - "discriminant": "event", - "singleUnionType": { - "wireDiscriminantValue": "heartbeat", - "shape": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolHeartbeat", - "object": { - "properties": [], - "extraProperties": null - } - } - }, - "baseProperties": [], - "extendProperties": [] - } - }, - "jsonExample": { - "event": "heartbeat" - } - } - } - ] - } - }, - "docs": null - }, - "codeSamples": null - } - ], - "autogeneratedExamples": [ - { - "example": { - "id": "900d867c", - "url": "/stream/protocol-collision", - "name": null, - "endpointHeaders": [], - "endpointPathParameters": [], - "queryParameters": [], - "servicePathParameters": [], - "serviceHeaders": [], - "rootPathParameters": [], - "request": { - "type": "reference", - "shape": { - "type": "named", - "shape": { - "type": "object", - "properties": [ - { - "name": "query", - "originalTypeDeclaration": { - "name": "StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamRequest" - }, - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": null, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "STRING", - "v2": { - "type": "string", - "default": null, - "validation": null - } - } - } - } - } - }, - "propertyAccess": null - } - ], - "extraProperties": null - }, - "typeName": { - "name": "StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamRequest" + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "The input prompt." + } + ], + "extra-properties": false, + "extendedProperties": [] + }, + "referencedTypes": [], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "Base schema for union stream requests. Contains the stream_response field that is inherited by all oneOf variants via allOf. This schema is also referenced directly by a non-streaming endpoint to ensure it is not excluded from the context." + }, + "type_:UnionStreamMessageVariant": { + "inline": null, + "name": { + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "shape": { + "_type": "object", + "extends": [ + { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + } + ], + "properties": [ + { + "name": "message", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "The message content." + } + ], + "extra-properties": false, + "extendedProperties": [ + { + "name": "stream_response", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": false } - }, - "jsonExample": {} - }, - "response": { - "type": "ok", - "value": { - "type": "sse", - "value": [ - { - "data": { - "shape": { - "type": "named", - "shape": { - "type": "union", - "discriminant": "event", - "singleUnionType": { - "wireDiscriminantValue": "heartbeat", - "shape": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolHeartbeat", - "object": { - "properties": [], - "extraProperties": null - } - } - }, - "baseProperties": [], - "extendProperties": [] - }, - "typeName": { - "name": "StreamProtocolCollisionResponse", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamProtocolCollisionResponse" - } - }, - "jsonExample": { - "event": "heartbeat" - } - }, - "event": "heartbeat" - } - ] } - }, - "docs": null + } } - } - ], - "pagination": null, - "transport": null, - "v2Examples": null, - "source": null, - "audiences": null, - "retries": null, - "apiPlayground": null, - "responseHeaders": [], - "availability": null, - "docs": "Same as endpoint 1, but the object data payload contains its own \"event\" property, which collides with the SSE envelope's \"event\" discriminator field. Tests whether generators correctly separate the protocol-level discriminant from the data-level field when context=protocol is specified." - }, - { - "id": "endpoint_.streamDataContext", - "name": "streamDataContext", - "displayName": "Explicit data context with discriminant flattened via allOf", - "auth": false, - "security": null, - "idempotent": false, - "baseUrl": null, - "v2BaseUrls": null, - "method": "POST", - "basePath": null, - "path": { - "head": "/stream/data-context", - "parts": [] - }, - "fullPath": { - "head": "stream/data-context", - "parts": [] - }, - "pathParameters": [], - "allPathParameters": [], - "queryParameters": [], - "headers": [], - "requestBody": { - "type": "reference", - "requestBodyType": { - "_type": "named", - "name": "StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamRequest", - "default": null, - "inline": null }, - "docs": null, - "contentType": "application/json", - "v2Examples": null + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "Whether to stream the response." }, - "v2RequestBodies": null, - "sdkRequest": { - "shape": { - "type": "justRequestBody", - "value": { - "type": "typeReference", - "requestBodyType": { - "_type": "named", - "name": "StreamRequest", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamRequest", + { + "name": "prompt", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", "default": null, - "inline": null - }, - "docs": null, - "contentType": null, - "v2Examples": null + "validation": null + } } }, - "requestParameterName": "request", - "streamParameter": null + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "The input prompt." + } + ] + }, + "referencedTypes": [ + "type_:UnionStreamRequestBase" + ], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "A user input message. Inherits stream_response from base via allOf." + }, + "type_:UnionStreamInterruptVariant": { + "inline": null, + "name": { + "name": "UnionStreamInterruptVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamInterruptVariant" + }, + "shape": { + "_type": "object", + "extends": [ + { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + } + ], + "properties": [], + "extra-properties": false, + "extendedProperties": [ + { + "name": "stream_response", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": false + } + } + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "Whether to stream the response." }, - "response": { - "body": { - "type": "streaming", - "value": { - "type": "sse", - "payload": { - "_type": "named", - "name": "StreamDataContextResponse", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:StreamDataContextResponse", + { + "name": "prompt", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", "default": null, - "inline": null - }, - "terminator": null, - "docs": "SSE stream with discriminator context set to data", - "v2Examples": null + "validation": null + } } }, - "status-code": null, - "isWildcardStatusCode": null, - "docs": null + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "The input prompt." + } + ] + }, + "referencedTypes": [ + "type_:UnionStreamRequestBase" + ], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "Cancels the current operation. Inherits stream_response from base." + }, + "type_:UnionStreamCompactVariant": { + "inline": null, + "name": { + "name": "UnionStreamCompactVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamCompactVariant" + }, + "shape": { + "_type": "object", + "extends": [ + { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + } + ], + "properties": [ + { + "name": "data", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "Compact data payload." + } + ], + "extra-properties": false, + "extendedProperties": [ + { + "name": "stream_response", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": false + } + } + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "Whether to stream the response." }, - "v2Responses": null, - "errors": [], - "userSpecifiedExamples": [ - { - "example": { - "id": "867f86a6", - "name": null, - "url": "/stream/data-context", + { + "name": "prompt", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "propertyAccess": null, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "availability": null, + "docs": "The input prompt." + } + ] + }, + "referencedTypes": [ + "type_:UnionStreamRequestBase" + ], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "Requests compaction of history. Inherits stream_response from base and adds compact-specific fields." + }, + "type_:UnionStreamRequest": { + "inline": null, + "name": { + "name": "UnionStreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequest" + }, + "shape": { + "_type": "union", + "discriminant": "type", + "extends": [], + "baseProperties": [], + "types": [ + { + "discriminantValue": "message", + "shape": { + "_type": "samePropertiesAsObject", + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "displayName": null, + "availability": null, + "docs": null + }, + { + "discriminantValue": "interrupt", + "shape": { + "_type": "samePropertiesAsObject", + "name": "UnionStreamInterruptVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamInterruptVariant" + }, + "displayName": null, + "availability": null, + "docs": null + }, + { + "discriminantValue": "compact", + "shape": { + "_type": "samePropertiesAsObject", + "name": "UnionStreamCompactVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamCompactVariant" + }, + "displayName": null, + "availability": null, + "docs": null + } + ], + "default": null, + "discriminatorContext": "data" + }, + "referencedTypes": [ + "type_:UnionStreamMessageVariant", + "type_:UnionStreamRequestBase", + "type_:UnionStreamInterruptVariant", + "type_:UnionStreamCompactVariant" + ], + "encoding": { + "json": {}, + "proto": null + }, + "source": null, + "userProvidedExamples": [], + "autogeneratedExamples": [], + "v2Examples": null, + "availability": null, + "docs": "A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict." + } + }, + "errors": {}, + "services": { + "service_": { + "availability": null, + "name": { + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "displayName": null, + "basePath": { + "head": "", + "parts": [] + }, + "headers": [], + "pathParameters": [], + "encoding": { + "json": {}, + "proto": null + }, + "transport": { + "type": "http" + }, + "endpoints": [ + { + "id": "endpoint_.streamProtocolNoCollision", + "name": "streamProtocolNoCollision", + "displayName": "Protocol context with no field collision and mixed data types", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/protocol-no-collision", + "parts": [] + }, + "fullPath": { + "head": "stream/protocol-no-collision", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "reference", + "requestBodyType": { + "_type": "named", + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest", + "default": null, + "inline": null + }, + "docs": null, + "contentType": "application/json", + "v2Examples": null + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "justRequestBody", + "value": { + "type": "typeReference", + "requestBodyType": { + "_type": "named", + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest", + "default": null, + "inline": null + }, + "docs": null, + "contentType": null, + "v2Examples": null + } + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "streaming", + "value": { + "type": "sse", + "payload": { + "_type": "named", + "name": "StreamProtocolNoCollisionResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamProtocolNoCollisionResponse", + "default": null, + "inline": null + }, + "terminator": null, + "docs": "SSE stream with protocol-level discrimination and mixed data types", + "v2Examples": null + } + }, + "status-code": null, + "isWildcardStatusCode": null, + "docs": null + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "bdd594d5", + "name": null, + "url": "/stream/protocol-no-collision", "rootPathParameters": [], "endpointPathParameters": [], "servicePathParameters": [], @@ -2382,13 +2911,13 @@ "shape": { "type": "named", "typeName": { - "typeId": "type_:StreamDataContextResponse", + "typeId": "type_:StreamProtocolNoCollisionResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, - "name": "StreamDataContextResponse", + "name": "StreamProtocolNoCollisionResponse", "displayName": null }, "shape": { @@ -2398,51 +2927,9 @@ "wireDiscriminantValue": "heartbeat", "shape": { "type": "samePropertiesAsObject", - "typeId": "type_:DataContextHeartbeat", + "typeId": "type_:ProtocolHeartbeat", "object": { - "properties": [ - { - "name": "timestamp", - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { - "shape": { - "type": "primitive", - "primitive": { - "type": "datetime", - "datetime": "2024-01-15T09:30:00.000Z", - "raw": "2024-01-15T09:30:00Z" - } - }, - "jsonExample": "2024-01-15T09:30:00Z" - }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "DATE_TIME", - "v2": null - } - } - } - }, - "jsonExample": "2024-01-15T09:30:00Z" - }, - "originalTypeDeclaration": { - "name": "HeartbeatPayload", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:HeartbeatPayload" - }, - "propertyAccess": null - } - ], + "properties": [], "extraProperties": null } } @@ -2452,7 +2939,6 @@ } }, "jsonExample": { - "timestamp": "2024-01-15T09:30:00Z", "event": "heartbeat" } } @@ -2468,8 +2954,8 @@ "autogeneratedExamples": [ { "example": { - "id": "46eb6335", - "url": "/stream/data-context", + "id": "c58dfb6", + "url": "/stream/protocol-no-collision", "name": null, "endpointHeaders": [], "endpointPathParameters": [], @@ -2550,51 +3036,9 @@ "wireDiscriminantValue": "heartbeat", "shape": { "type": "samePropertiesAsObject", - "typeId": "type_:DataContextHeartbeat", + "typeId": "type_:ProtocolHeartbeat", "object": { - "properties": [ - { - "name": "timestamp", - "originalTypeDeclaration": { - "name": "DataContextHeartbeat", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:DataContextHeartbeat" - }, - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { - "shape": { - "type": "primitive", - "primitive": { - "type": "datetime", - "datetime": "2024-01-15T09:30:00.000Z", - "raw": "2024-01-15T09:30:00Z" - } - }, - "jsonExample": "2024-01-15T09:30:00Z" - }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "DATE_TIME", - "v2": null - } - } - } - }, - "jsonExample": "2024-01-15T09:30:00Z" - }, - "propertyAccess": null - } - ], + "properties": [], "extraProperties": null } } @@ -2603,22 +3047,21 @@ "extendProperties": [] }, "typeName": { - "name": "StreamDataContextResponse", + "name": "StreamProtocolNoCollisionResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:StreamDataContextResponse" + "typeId": "type_:StreamProtocolNoCollisionResponse" } }, "jsonExample": { - "event": "heartbeat", - "timestamp": "2024-01-15T09:30:00Z" + "event": "heartbeat" } }, - "event": "" + "event": "heartbeat" } ] } @@ -2636,12 +3079,12 @@ "apiPlayground": null, "responseHeaders": [], "availability": null, - "docs": "x-fern-discriminator-context is explicitly set to \"data\" (the default value). Each variant uses allOf to extend a payload schema and adds the \"event\" discriminant property at the same level. There is no \"data\" wrapper. The discriminant and payload fields coexist in a single flat object. This matches the real-world pattern used by customers with context=data." + "docs": "Uses discriminator with mapping, x-fern-discriminator-context set to protocol. Because the discriminant is at the protocol level, the data field can be any type or absent entirely. Demonstrates heartbeat (no data), string literal, number literal, and object data payloads." }, { - "id": "endpoint_.streamNoContext", - "name": "streamNoContext", - "displayName": "No context extension, defaults to data context", + "id": "endpoint_.streamProtocolCollision", + "name": "streamProtocolCollision", + "displayName": "Protocol context with event field collision and mixed data types", "auth": false, "security": null, "idempotent": false, @@ -2650,11 +3093,11 @@ "method": "POST", "basePath": null, "path": { - "head": "/stream/no-context", + "head": "/stream/protocol-collision", "parts": [] }, "fullPath": { - "head": "stream/no-context", + "head": "stream/protocol-collision", "parts": [] }, "pathParameters": [], @@ -2714,19 +3157,19 @@ "type": "sse", "payload": { "_type": "named", - "name": "StreamNoContextResponse", + "name": "StreamProtocolCollisionResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:StreamNoContextResponse", + "typeId": "type_:StreamProtocolCollisionResponse", "default": null, "inline": null }, "terminator": null, - "docs": "SSE stream with no discriminator context hint", + "docs": "SSE stream with protocol context and event field collision", "v2Examples": null } }, @@ -2739,9 +3182,9 @@ "userSpecifiedExamples": [ { "example": { - "id": "867f86a6", + "id": "bdd594d5", "name": null, - "url": "/stream/no-context", + "url": "/stream/protocol-collision", "rootPathParameters": [], "endpointPathParameters": [], "servicePathParameters": [], @@ -2781,13 +3224,13 @@ "shape": { "type": "named", "typeName": { - "typeId": "type_:StreamNoContextResponse", + "typeId": "type_:StreamProtocolCollisionResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, - "name": "StreamNoContextResponse", + "name": "StreamProtocolCollisionResponse", "displayName": null }, "shape": { @@ -2797,51 +3240,9 @@ "wireDiscriminantValue": "heartbeat", "shape": { "type": "samePropertiesAsObject", - "typeId": "type_:DataContextHeartbeat", + "typeId": "type_:ProtocolHeartbeat", "object": { - "properties": [ - { - "name": "timestamp", - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { - "shape": { - "type": "primitive", - "primitive": { - "type": "datetime", - "datetime": "2024-01-15T09:30:00.000Z", - "raw": "2024-01-15T09:30:00Z" - } - }, - "jsonExample": "2024-01-15T09:30:00Z" - }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "DATE_TIME", - "v2": null - } - } - } - }, - "jsonExample": "2024-01-15T09:30:00Z" - }, - "originalTypeDeclaration": { - "name": "HeartbeatPayload", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:HeartbeatPayload" - }, - "propertyAccess": null - } - ], + "properties": [], "extraProperties": null } } @@ -2851,7 +3252,6 @@ } }, "jsonExample": { - "timestamp": "2024-01-15T09:30:00Z", "event": "heartbeat" } } @@ -2867,8 +3267,8 @@ "autogeneratedExamples": [ { "example": { - "id": "4c0d87b7", - "url": "/stream/no-context", + "id": "900d867c", + "url": "/stream/protocol-collision", "name": null, "endpointHeaders": [], "endpointPathParameters": [], @@ -2949,51 +3349,9 @@ "wireDiscriminantValue": "heartbeat", "shape": { "type": "samePropertiesAsObject", - "typeId": "type_:DataContextHeartbeat", + "typeId": "type_:ProtocolHeartbeat", "object": { - "properties": [ - { - "name": "timestamp", - "originalTypeDeclaration": { - "name": "DataContextHeartbeat", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:DataContextHeartbeat" - }, - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { - "shape": { - "type": "primitive", - "primitive": { - "type": "datetime", - "datetime": "2024-01-15T09:30:00.000Z", - "raw": "2024-01-15T09:30:00Z" - } - }, - "jsonExample": "2024-01-15T09:30:00Z" - }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "DATE_TIME", - "v2": null - } - } - } - }, - "jsonExample": "2024-01-15T09:30:00Z" - }, - "propertyAccess": null - } - ], + "properties": [], "extraProperties": null } } @@ -3002,22 +3360,21 @@ "extendProperties": [] }, "typeName": { - "name": "StreamNoContextResponse", + "name": "StreamProtocolCollisionResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:StreamNoContextResponse" + "typeId": "type_:StreamProtocolCollisionResponse" } }, "jsonExample": { - "event": "heartbeat", - "timestamp": "2024-01-15T09:30:00Z" + "event": "heartbeat" } }, - "event": "" + "event": "heartbeat" } ] } @@ -3035,12 +3392,12 @@ "apiPlayground": null, "responseHeaders": [], "availability": null, - "docs": "The x-fern-discriminator-context extension is omitted entirely. Tests whether Fern correctly infers the default behavior (context=data) when the extension is absent. Same flat allOf pattern as endpoint 3." + "docs": "Same as endpoint 1, but the object data payload contains its own \"event\" property, which collides with the SSE envelope's \"event\" discriminator field. Tests whether generators correctly separate the protocol-level discriminant from the data-level field when context=protocol is specified." }, { - "id": "endpoint_.streamProtocolWithFlatSchema", - "name": "streamProtocolWithFlatSchema", - "displayName": "Protocol context with flat allOf schema pattern", + "id": "endpoint_.streamDataContext", + "name": "streamDataContext", + "displayName": "Explicit data context with discriminant flattened via allOf", "auth": false, "security": null, "idempotent": false, @@ -3049,11 +3406,11 @@ "method": "POST", "basePath": null, "path": { - "head": "/stream/protocol-with-flat-schema", + "head": "/stream/data-context", "parts": [] }, "fullPath": { - "head": "stream/protocol-with-flat-schema", + "head": "stream/data-context", "parts": [] }, "pathParameters": [], @@ -3113,19 +3470,19 @@ "type": "sse", "payload": { "_type": "named", - "name": "StreamProtocolWithFlatSchemaResponse", + "name": "StreamDataContextResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:StreamProtocolWithFlatSchemaResponse", + "typeId": "type_:StreamDataContextResponse", "default": null, "inline": null }, "terminator": null, - "docs": "SSE stream with protocol context but flat allOf schemas", + "docs": "SSE stream with discriminator context set to data", "v2Examples": null } }, @@ -3140,7 +3497,7 @@ "example": { "id": "867f86a6", "name": null, - "url": "/stream/protocol-with-flat-schema", + "url": "/stream/data-context", "rootPathParameters": [], "endpointPathParameters": [], "servicePathParameters": [], @@ -3180,13 +3537,13 @@ "shape": { "type": "named", "typeName": { - "typeId": "type_:StreamProtocolWithFlatSchemaResponse", + "typeId": "type_:StreamDataContextResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, - "name": "StreamProtocolWithFlatSchemaResponse", + "name": "StreamDataContextResponse", "displayName": null }, "shape": { @@ -3266,8 +3623,8 @@ "autogeneratedExamples": [ { "example": { - "id": "d8d06531", - "url": "/stream/protocol-with-flat-schema", + "id": "46eb6335", + "url": "/stream/data-context", "name": null, "endpointHeaders": [], "endpointPathParameters": [], @@ -3401,14 +3758,14 @@ "extendProperties": [] }, "typeName": { - "name": "StreamProtocolWithFlatSchemaResponse", + "name": "StreamDataContextResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:StreamProtocolWithFlatSchemaResponse" + "typeId": "type_:StreamDataContextResponse" } }, "jsonExample": { @@ -3416,7 +3773,7 @@ "timestamp": "2024-01-15T09:30:00Z" } }, - "event": "heartbeat" + "event": "" } ] } @@ -3434,12 +3791,12 @@ "apiPlayground": null, "responseHeaders": [], "availability": null, - "docs": "Mismatched combination: context=protocol with the flat allOf schema pattern that is normally used with context=data. Shows what happens when the discriminant is declared as protocol-level but the schema uses allOf to flatten the event field alongside payload fields instead of wrapping them in a data field." + "docs": "x-fern-discriminator-context is explicitly set to \"data\" (the default value). Each variant uses allOf to extend a payload schema and adds the \"event\" discriminant property at the same level. There is no \"data\" wrapper. The discriminant and payload fields coexist in a single flat object. This matches the real-world pattern used by customers with context=data." }, { - "id": "endpoint_.streamDataContextWithEnvelopeSchema", - "name": "streamDataContextWithEnvelopeSchema", - "displayName": "Data context with envelope+data schema pattern", + "id": "endpoint_.streamNoContext", + "name": "streamNoContext", + "displayName": "No context extension, defaults to data context", "auth": false, "security": null, "idempotent": false, @@ -3448,11 +3805,11 @@ "method": "POST", "basePath": null, "path": { - "head": "/stream/data-context-with-envelope-schema", + "head": "/stream/no-context", "parts": [] }, "fullPath": { - "head": "stream/data-context-with-envelope-schema", + "head": "stream/no-context", "parts": [] }, "pathParameters": [], @@ -3512,19 +3869,19 @@ "type": "sse", "payload": { "_type": "named", - "name": "StreamDataContextWithEnvelopeSchemaResponse", + "name": "StreamNoContextResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:StreamDataContextWithEnvelopeSchemaResponse", + "typeId": "type_:StreamNoContextResponse", "default": null, "inline": null }, "terminator": null, - "docs": "SSE stream with data context but envelope+data schemas", + "docs": "SSE stream with no discriminator context hint", "v2Examples": null } }, @@ -3537,9 +3894,9 @@ "userSpecifiedExamples": [ { "example": { - "id": "bdd594d5", + "id": "867f86a6", "name": null, - "url": "/stream/data-context-with-envelope-schema", + "url": "/stream/no-context", "rootPathParameters": [], "endpointPathParameters": [], "servicePathParameters": [], @@ -3579,13 +3936,13 @@ "shape": { "type": "named", "typeName": { - "typeId": "type_:StreamDataContextWithEnvelopeSchemaResponse", + "typeId": "type_:StreamNoContextResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, - "name": "StreamDataContextWithEnvelopeSchemaResponse", + "name": "StreamNoContextResponse", "displayName": null }, "shape": { @@ -3595,9 +3952,51 @@ "wireDiscriminantValue": "heartbeat", "shape": { "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolHeartbeat", + "typeId": "type_:DataContextHeartbeat", "object": { - "properties": [], + "properties": [ + { + "name": "timestamp", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "datetime", + "datetime": "2024-01-15T09:30:00.000Z", + "raw": "2024-01-15T09:30:00Z" + } + }, + "jsonExample": "2024-01-15T09:30:00Z" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "DATE_TIME", + "v2": null + } + } + } + }, + "jsonExample": "2024-01-15T09:30:00Z" + }, + "originalTypeDeclaration": { + "name": "HeartbeatPayload", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:HeartbeatPayload" + }, + "propertyAccess": null + } + ], "extraProperties": null } } @@ -3607,6 +4006,7 @@ } }, "jsonExample": { + "timestamp": "2024-01-15T09:30:00Z", "event": "heartbeat" } } @@ -3622,8 +4022,8 @@ "autogeneratedExamples": [ { "example": { - "id": "6f48f0d6", - "url": "/stream/data-context-with-envelope-schema", + "id": "4c0d87b7", + "url": "/stream/no-context", "name": null, "endpointHeaders": [], "endpointPathParameters": [], @@ -3704,9 +4104,51 @@ "wireDiscriminantValue": "heartbeat", "shape": { "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolHeartbeat", + "typeId": "type_:DataContextHeartbeat", "object": { - "properties": [], + "properties": [ + { + "name": "timestamp", + "originalTypeDeclaration": { + "name": "DataContextHeartbeat", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:DataContextHeartbeat" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "datetime", + "datetime": "2024-01-15T09:30:00.000Z", + "raw": "2024-01-15T09:30:00Z" + } + }, + "jsonExample": "2024-01-15T09:30:00Z" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "DATE_TIME", + "v2": null + } + } + } + }, + "jsonExample": "2024-01-15T09:30:00Z" + }, + "propertyAccess": null + } + ], "extraProperties": null } } @@ -3715,18 +4157,19 @@ "extendProperties": [] }, "typeName": { - "name": "StreamDataContextWithEnvelopeSchemaResponse", + "name": "StreamNoContextResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:StreamDataContextWithEnvelopeSchemaResponse" + "typeId": "type_:StreamNoContextResponse" } }, "jsonExample": { - "event": "heartbeat" + "event": "heartbeat", + "timestamp": "2024-01-15T09:30:00Z" } }, "event": "" @@ -3747,12 +4190,12 @@ "apiPlayground": null, "responseHeaders": [], "availability": null, - "docs": "Mismatched combination: context=data with the envelope+data schema pattern that is normally used with context=protocol. Shows what happens when the discriminant is declared as data-level but the schema separates the event field and data field into an envelope structure." + "docs": "The x-fern-discriminator-context extension is omitted entirely. Tests whether Fern correctly infers the default behavior (context=data) when the extension is absent. Same flat allOf pattern as endpoint 3." }, { - "id": "endpoint_.streamOasSpecNative", - "name": "streamOasSpecNative", - "displayName": "OAS 3.2 spec-native SSE pattern with inline variants and contentSchema", + "id": "endpoint_.streamProtocolWithFlatSchema", + "name": "streamProtocolWithFlatSchema", + "displayName": "Protocol context with flat allOf schema pattern", "auth": false, "security": null, "idempotent": false, @@ -3761,11 +4204,11 @@ "method": "POST", "basePath": null, "path": { - "head": "/stream/oas-spec-native", + "head": "/stream/protocol-with-flat-schema", "parts": [] }, "fullPath": { - "head": "stream/oas-spec-native", + "head": "stream/protocol-with-flat-schema", "parts": [] }, "pathParameters": [], @@ -3825,19 +4268,19 @@ "type": "sse", "payload": { "_type": "named", - "name": "Event", + "name": "StreamProtocolWithFlatSchemaResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:Event", + "typeId": "type_:StreamProtocolWithFlatSchemaResponse", "default": null, "inline": null }, "terminator": null, - "docs": "SSE stream following the OAS 3.2 spec example pattern", + "docs": "SSE stream with protocol context but flat allOf schemas", "v2Examples": null } }, @@ -3850,9 +4293,9 @@ "userSpecifiedExamples": [ { "example": { - "id": "13f92cd8", + "id": "867f86a6", "name": null, - "url": "/stream/oas-spec-native", + "url": "/stream/protocol-with-flat-schema", "rootPathParameters": [], "endpointPathParameters": [], "servicePathParameters": [], @@ -3892,189 +4335,78 @@ "shape": { "type": "named", "typeName": { - "typeId": "type_:Event", + "typeId": "type_:StreamProtocolWithFlatSchemaResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, - "name": "Event", + "name": "StreamProtocolWithFlatSchemaResponse", "displayName": null }, "shape": { - "type": "object", - "properties": [ - { - "name": "data", - "value": { - "shape": { - "type": "primitive", - "primitive": { - "type": "string", - "string": { - "original": "data" - } - } - }, - "jsonExample": "data" - }, - "originalTypeDeclaration": { - "typeId": "type_:Event", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "name": "Event", - "displayName": null - }, - "propertyAccess": null - }, - { - "name": "event", - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { + "type": "union", + "discriminant": "event", + "singleUnionType": { + "wireDiscriminantValue": "heartbeat", + "shape": { + "type": "samePropertiesAsObject", + "typeId": "type_:DataContextHeartbeat", + "object": { + "properties": [ + { + "name": "timestamp", + "value": { "shape": { - "type": "primitive", - "primitive": { - "type": "string", - "string": { - "original": "event" + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "datetime", + "datetime": "2024-01-15T09:30:00.000Z", + "raw": "2024-01-15T09:30:00Z" + } + }, + "jsonExample": "2024-01-15T09:30:00Z" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "DATE_TIME", + "v2": null + } } } }, - "jsonExample": "event" + "jsonExample": "2024-01-15T09:30:00Z" }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "STRING", - "v2": { - "type": "string", - "default": null, - "validation": null - } - } - } + "originalTypeDeclaration": { + "name": "HeartbeatPayload", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:HeartbeatPayload" + }, + "propertyAccess": null } - }, - "jsonExample": "event" - }, - "originalTypeDeclaration": { - "typeId": "type_:Event", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "name": "Event", - "displayName": null - }, - "propertyAccess": null - }, - { - "name": "id", - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { - "shape": { - "type": "primitive", - "primitive": { - "type": "string", - "string": { - "original": "id" - } - } - }, - "jsonExample": "id" - }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "STRING", - "v2": { - "type": "string", - "default": null, - "validation": null - } - } - } - } - }, - "jsonExample": "id" - }, - "originalTypeDeclaration": { - "typeId": "type_:Event", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "name": "Event", - "displayName": null - }, - "propertyAccess": null - }, - { - "name": "retry", - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { - "shape": { - "type": "primitive", - "primitive": { - "type": "integer", - "integer": 1 - } - }, - "jsonExample": 1 - }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "INTEGER", - "v2": { - "type": "integer", - "default": null, - "validation": null - } - } - } - } - }, - "jsonExample": 1 - }, - "originalTypeDeclaration": { - "typeId": "type_:Event", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "name": "Event", - "displayName": null - }, - "propertyAccess": null + ], + "extraProperties": null + } } - ], - "extraProperties": null + }, + "baseProperties": [], + "extendProperties": [] } }, "jsonExample": { - "data": "data", - "event": "event", - "id": "id", - "retry": 1 + "timestamp": "2024-01-15T09:30:00Z", + "event": "heartbeat" } } } @@ -4089,8 +4421,8 @@ "autogeneratedExamples": [ { "example": { - "id": "f6457c60", - "url": "/stream/oas-spec-native", + "id": "d8d06531", + "url": "/stream/protocol-with-flat-schema", "name": null, "endpointHeaders": [], "endpointPathParameters": [], @@ -4165,286 +4497,8730 @@ "shape": { "type": "named", "shape": { - "type": "object", - "properties": [ - { - "name": "data", - "originalTypeDeclaration": { - "name": "Event", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:Event" - }, - "value": { - "shape": { - "type": "primitive", - "primitive": { - "type": "string", - "string": { - "original": "data" - } - } - }, - "jsonExample": "data" - }, - "propertyAccess": null - }, - { - "name": "event", - "originalTypeDeclaration": { - "name": "Event", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:Event" - }, - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { - "shape": { - "type": "primitive", - "primitive": { - "type": "string", - "string": { - "original": "event" - } - } + "type": "union", + "discriminant": "event", + "singleUnionType": { + "wireDiscriminantValue": "heartbeat", + "shape": { + "type": "samePropertiesAsObject", + "typeId": "type_:DataContextHeartbeat", + "object": { + "properties": [ + { + "name": "timestamp", + "originalTypeDeclaration": { + "name": "DataContextHeartbeat", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null }, - "jsonExample": "event" + "displayName": null, + "typeId": "type_:DataContextHeartbeat" }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "STRING", - "v2": { - "type": "string", - "default": null, - "validation": null - } - } - } - } - }, - "jsonExample": "event" - }, - "propertyAccess": null - }, - { - "name": "id", - "originalTypeDeclaration": { - "name": "Event", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:Event" - }, - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { + "value": { "shape": { - "type": "primitive", - "primitive": { - "type": "string", - "string": { - "original": "id" + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "datetime", + "datetime": "2024-01-15T09:30:00.000Z", + "raw": "2024-01-15T09:30:00Z" + } + }, + "jsonExample": "2024-01-15T09:30:00Z" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "DATE_TIME", + "v2": null + } } } }, - "jsonExample": "id" + "jsonExample": "2024-01-15T09:30:00Z" }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "STRING", - "v2": { - "type": "string", - "default": null, - "validation": null - } - } - } - } - }, - "jsonExample": "id" - }, - "propertyAccess": null - }, - { - "name": "retry", - "originalTypeDeclaration": { - "name": "Event", - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - }, - "displayName": null, - "typeId": "type_:Event" - }, - "value": { - "shape": { - "type": "container", - "container": { - "type": "optional", - "optional": { - "shape": { - "type": "primitive", - "primitive": { - "type": "integer", - "integer": 1 - } - }, - "jsonExample": 1 - }, - "valueType": { - "_type": "primitive", - "primitive": { - "v1": "INTEGER", - "v2": { - "type": "integer", - "default": null, - "validation": { - "min": 0, - "max": null, - "exclusiveMin": null, - "exclusiveMax": null, - "multipleOf": null - } - } - } - } + "propertyAccess": null } - }, - "jsonExample": 1 - }, - "propertyAccess": null + ], + "extraProperties": null + } } - ], - "extraProperties": null + }, + "baseProperties": [], + "extendProperties": [] }, "typeName": { - "name": "Event", + "name": "StreamProtocolWithFlatSchemaResponse", "fernFilepath": { "allParts": [], "packagePath": [], "file": null }, "displayName": null, - "typeId": "type_:Event" + "typeId": "type_:StreamProtocolWithFlatSchemaResponse" } }, "jsonExample": { - "data": "data", - "event": "event", - "id": "id", - "retry": 1 + "event": "heartbeat", + "timestamp": "2024-01-15T09:30:00Z" } }, - "event": "" + "event": "heartbeat" } ] } }, - "docs": null + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Mismatched combination: context=protocol with the flat allOf schema pattern that is normally used with context=data. Shows what happens when the discriminant is declared as protocol-level but the schema uses allOf to flatten the event field alongside payload fields instead of wrapping them in a data field." + }, + { + "id": "endpoint_.streamDataContextWithEnvelopeSchema", + "name": "streamDataContextWithEnvelopeSchema", + "displayName": "Data context with envelope+data schema pattern", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/data-context-with-envelope-schema", + "parts": [] + }, + "fullPath": { + "head": "stream/data-context-with-envelope-schema", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "reference", + "requestBodyType": { + "_type": "named", + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest", + "default": null, + "inline": null + }, + "docs": null, + "contentType": "application/json", + "v2Examples": null + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "justRequestBody", + "value": { + "type": "typeReference", + "requestBodyType": { + "_type": "named", + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest", + "default": null, + "inline": null + }, + "docs": null, + "contentType": null, + "v2Examples": null + } + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "streaming", + "value": { + "type": "sse", + "payload": { + "_type": "named", + "name": "StreamDataContextWithEnvelopeSchemaResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamDataContextWithEnvelopeSchemaResponse", + "default": null, + "inline": null + }, + "terminator": null, + "docs": "SSE stream with data context but envelope+data schemas", + "v2Examples": null + } + }, + "status-code": null, + "isWildcardStatusCode": null, + "docs": null + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "bdd594d5", + "name": null, + "url": "/stream/data-context-with-envelope-schema", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "StreamRequest", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [], + "extraProperties": null + } + }, + "jsonExample": {} + }, + "response": { + "type": "ok", + "value": { + "type": "sse", + "value": [ + { + "event": "", + "data": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:StreamDataContextWithEnvelopeSchemaResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "StreamDataContextWithEnvelopeSchemaResponse", + "displayName": null + }, + "shape": { + "type": "union", + "discriminant": "event", + "singleUnionType": { + "wireDiscriminantValue": "heartbeat", + "shape": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolHeartbeat", + "object": { + "properties": [], + "extraProperties": null + } + } + }, + "baseProperties": [], + "extendProperties": [] + } + }, + "jsonExample": { + "event": "heartbeat" + } + } + } + ] + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "6f48f0d6", + "url": "/stream/data-context-with-envelope-schema", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "query", + "originalTypeDeclaration": { + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": null, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + } + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest" + } + }, + "jsonExample": {} + }, + "response": { + "type": "ok", + "value": { + "type": "sse", + "value": [ + { + "data": { + "shape": { + "type": "named", + "shape": { + "type": "union", + "discriminant": "event", + "singleUnionType": { + "wireDiscriminantValue": "heartbeat", + "shape": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolHeartbeat", + "object": { + "properties": [], + "extraProperties": null + } + } + }, + "baseProperties": [], + "extendProperties": [] + }, + "typeName": { + "name": "StreamDataContextWithEnvelopeSchemaResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamDataContextWithEnvelopeSchemaResponse" + } + }, + "jsonExample": { + "event": "heartbeat" + } + }, + "event": "" + } + ] + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Mismatched combination: context=data with the envelope+data schema pattern that is normally used with context=protocol. Shows what happens when the discriminant is declared as data-level but the schema separates the event field and data field into an envelope structure." + }, + { + "id": "endpoint_.streamOasSpecNative", + "name": "streamOasSpecNative", + "displayName": "OAS 3.2 spec-native SSE pattern with inline variants and contentSchema", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/oas-spec-native", + "parts": [] + }, + "fullPath": { + "head": "stream/oas-spec-native", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "reference", + "requestBodyType": { + "_type": "named", + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest", + "default": null, + "inline": null + }, + "docs": null, + "contentType": "application/json", + "v2Examples": null + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "justRequestBody", + "value": { + "type": "typeReference", + "requestBodyType": { + "_type": "named", + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest", + "default": null, + "inline": null + }, + "docs": null, + "contentType": null, + "v2Examples": null + } + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "streaming", + "value": { + "type": "sse", + "payload": { + "_type": "named", + "name": "Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:Event", + "default": null, + "inline": null + }, + "terminator": null, + "docs": "SSE stream following the OAS 3.2 spec example pattern", + "v2Examples": null + } + }, + "status-code": null, + "isWildcardStatusCode": null, + "docs": null + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "13f92cd8", + "name": null, + "url": "/stream/oas-spec-native", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "StreamRequest", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [], + "extraProperties": null + } + }, + "jsonExample": {} + }, + "response": { + "type": "ok", + "value": { + "type": "sse", + "value": [ + { + "event": "", + "data": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "Event", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "data", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "data" + } + } + }, + "jsonExample": "data" + }, + "originalTypeDeclaration": { + "typeId": "type_:Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "Event", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "event", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "event" + } + } + }, + "jsonExample": "event" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "event" + }, + "originalTypeDeclaration": { + "typeId": "type_:Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "Event", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "id", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "id" + } + } + }, + "jsonExample": "id" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "id" + }, + "originalTypeDeclaration": { + "typeId": "type_:Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "Event", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "retry", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": 1 + }, + "originalTypeDeclaration": { + "typeId": "type_:Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "Event", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "data": "data", + "event": "event", + "id": "id", + "retry": 1 + } + } + } + ] + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "f6457c60", + "url": "/stream/oas-spec-native", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "query", + "originalTypeDeclaration": { + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": null, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + } + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest" + } + }, + "jsonExample": {} + }, + "response": { + "type": "ok", + "value": { + "type": "sse", + "value": [ + { + "data": { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "data", + "originalTypeDeclaration": { + "name": "Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:Event" + }, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "data" + } + } + }, + "jsonExample": "data" + }, + "propertyAccess": null + }, + { + "name": "event", + "originalTypeDeclaration": { + "name": "Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:Event" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "event" + } + } + }, + "jsonExample": "event" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "event" + }, + "propertyAccess": null + }, + { + "name": "id", + "originalTypeDeclaration": { + "name": "Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:Event" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "id" + } + } + }, + "jsonExample": "id" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "id" + }, + "propertyAccess": null + }, + { + "name": "retry", + "originalTypeDeclaration": { + "name": "Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:Event" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": { + "min": 0, + "max": null, + "exclusiveMin": null, + "exclusiveMax": null, + "multipleOf": null + } + } + } + } + } + }, + "jsonExample": 1 + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "Event", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:Event" + } + }, + "jsonExample": { + "data": "data", + "event": "event", + "id": "id", + "retry": 1 + } + }, + "event": "" + } + ] + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Follows the pattern from the OAS 3.2 specification's own SSE example. The itemSchema extends a base Event schema via $ref and uses inline oneOf variants with const on the event field to distinguish event types. Data fields use contentSchema/contentMediaType for structured payloads. No discriminator object is used. Event type resolution relies on const matching." + }, + { + "id": "endpoint_.streamXFernStreamingCondition_stream", + "name": "streamXFernStreamingCondition_stream", + "displayName": "x-fern-streaming with stream-condition and $ref request body", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/x-fern-streaming-condition", + "parts": [] + }, + "fullPath": { + "head": "stream/x-fern-streaming-condition", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "inlinedRequestBody", + "name": "StreamXFernStreamingConditionStreamRequest", + "extends": [], + "properties": [ + { + "name": "query", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The prompt or query to complete." + }, + { + "name": "stream", + "valueType": { + "_type": "container", + "container": { + "_type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "Whether to stream the response." + } + ], + "extra-properties": false, + "extendedProperties": [], + "docs": null, + "v2Examples": null, + "contentType": "application/json" + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "wrapper", + "wrapperName": "StreamXFernStreamingConditionStreamRequest", + "bodyKey": "body", + "includePathParameters": false, + "onlyPathParameters": false + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "streaming", + "value": { + "type": "json", + "payload": { + "_type": "named", + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk", + "default": null, + "inline": null + }, + "terminator": null, + "docs": "", + "v2Examples": null + } + }, + "status-code": null, + "isWildcardStatusCode": null, + "docs": null + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "9e6c48a6", + "name": null, + "url": "/stream/x-fern-streaming-condition", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "query", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "query" + } + } + }, + "jsonExample": "query" + }, + "originalTypeDeclaration": null + }, + { + "name": "stream", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "jsonExample": true + }, + "originalTypeDeclaration": null + } + ], + "extraProperties": null, + "jsonExample": { + "query": "query", + "stream": true + } + }, + "response": { + "type": "ok", + "value": { + "type": "stream", + "value": [ + { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "delta", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "delta" + } + } + }, + "jsonExample": "delta" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "delta" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "tokens", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": 1 + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "delta": "delta", + "tokens": 1 + } + } + ] + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "fbda279e", + "url": "/stream/x-fern-streaming-condition", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "query", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "query" + } + } + }, + "jsonExample": "query" + } + }, + { + "name": "stream", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "jsonExample": true + } + } + ], + "extraProperties": null, + "jsonExample": { + "query": "query", + "stream": true + } + }, + "response": { + "type": "ok", + "value": { + "type": "stream", + "value": [ + { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "delta", + "originalTypeDeclaration": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "delta" + } + } + }, + "jsonExample": "delta" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "delta" + }, + "propertyAccess": null + }, + { + "name": "tokens", + "originalTypeDeclaration": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": 1 + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + } + }, + "jsonExample": { + "delta": "delta", + "tokens": 1 + } + } + ] + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas." + }, + { + "id": "endpoint_.streamXFernStreamingCondition", + "name": "streamXFernStreamingCondition", + "displayName": "x-fern-streaming with stream-condition and $ref request body", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/x-fern-streaming-condition", + "parts": [] + }, + "fullPath": { + "head": "stream/x-fern-streaming-condition", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "inlinedRequestBody", + "name": "StreamXFernStreamingConditionRequest", + "extends": [], + "properties": [ + { + "name": "query", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The prompt or query to complete." + }, + { + "name": "stream", + "valueType": { + "_type": "container", + "container": { + "_type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "Whether to stream the response." + } + ], + "extra-properties": false, + "extendedProperties": [], + "docs": null, + "v2Examples": null, + "contentType": "application/json" + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "wrapper", + "wrapperName": "StreamXFernStreamingConditionRequest", + "bodyKey": "body", + "includePathParameters": false, + "onlyPathParameters": false + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "json", + "value": { + "type": "response", + "responseBodyType": { + "_type": "named", + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse", + "default": null, + "inline": null + }, + "docs": "", + "v2Examples": null + } + }, + "status-code": 200, + "isWildcardStatusCode": null, + "docs": "" + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "a81f32a2", + "name": null, + "url": "/stream/x-fern-streaming-condition", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "query", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "query" + } + } + }, + "jsonExample": "query" + }, + "originalTypeDeclaration": null + }, + { + "name": "stream", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "jsonExample": false + }, + "originalTypeDeclaration": null + } + ], + "extraProperties": null, + "jsonExample": { + "query": "query", + "stream": false + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponseFinishReason", + "displayName": null + }, + "shape": { + "type": "enum", + "value": "complete" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "f103dbd8", + "url": "/stream/x-fern-streaming-condition", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "query", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "query" + } + } + }, + "jsonExample": "query" + } + }, + { + "name": "stream", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "jsonExample": false + } + } + ], + "extraProperties": null, + "jsonExample": { + "query": "query", + "stream": false + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "shape": { + "type": "enum", + "value": "complete" + }, + "typeName": { + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas." + }, + { + "id": "endpoint_.streamXFernStreamingSharedSchema_stream", + "name": "streamXFernStreamingSharedSchema_stream", + "displayName": "x-fern-streaming with shared request schema", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/x-fern-streaming-shared-schema", + "parts": [] + }, + "fullPath": { + "head": "stream/x-fern-streaming-shared-schema", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "inlinedRequestBody", + "name": "StreamXFernStreamingSharedSchemaStreamRequest", + "extends": [], + "properties": [ + { + "name": "prompt", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The prompt to complete." + }, + { + "name": "model", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The model to use." + }, + { + "name": "stream", + "valueType": { + "_type": "container", + "container": { + "_type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "Whether to stream the response." + } + ], + "extra-properties": false, + "extendedProperties": [], + "docs": null, + "v2Examples": null, + "contentType": "application/json" + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "wrapper", + "wrapperName": "StreamXFernStreamingSharedSchemaStreamRequest", + "bodyKey": "body", + "includePathParameters": false, + "onlyPathParameters": false + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "streaming", + "value": { + "type": "json", + "payload": { + "_type": "named", + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk", + "default": null, + "inline": null + }, + "terminator": null, + "docs": "", + "v2Examples": null + } + }, + "status-code": null, + "isWildcardStatusCode": null, + "docs": null + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "e51cd0a8", + "name": null, + "url": "/stream/x-fern-streaming-shared-schema", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "prompt", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + }, + "originalTypeDeclaration": null + }, + { + "name": "model", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "model" + } + } + }, + "jsonExample": "model" + }, + "originalTypeDeclaration": null + }, + { + "name": "stream", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "jsonExample": true + }, + "originalTypeDeclaration": null + } + ], + "extraProperties": null, + "jsonExample": { + "prompt": "prompt", + "model": "model", + "stream": true + } + }, + "response": { + "type": "ok", + "value": { + "type": "stream", + "value": [ + { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "delta", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "delta" + } + } + }, + "jsonExample": "delta" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "delta" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "tokens", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": 1 + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "delta": "delta", + "tokens": 1 + } + } + ] + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "c411ffe9", + "url": "/stream/x-fern-streaming-shared-schema", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "prompt", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + } + }, + { + "name": "model", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "model" + } + } + }, + "jsonExample": "model" + } + }, + { + "name": "stream", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "jsonExample": true + } + } + ], + "extraProperties": null, + "jsonExample": { + "prompt": "prompt", + "model": "model", + "stream": true + } + }, + "response": { + "type": "ok", + "value": { + "type": "stream", + "value": [ + { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "delta", + "originalTypeDeclaration": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "delta" + } + } + }, + "jsonExample": "delta" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "delta" + }, + "propertyAccess": null + }, + { + "name": "tokens", + "originalTypeDeclaration": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": 1 + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + } + }, + "jsonExample": { + "delta": "delta", + "tokens": 1 + } + } + ] + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing." + }, + { + "id": "endpoint_.streamXFernStreamingSharedSchema", + "name": "streamXFernStreamingSharedSchema", + "displayName": "x-fern-streaming with shared request schema", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/x-fern-streaming-shared-schema", + "parts": [] + }, + "fullPath": { + "head": "stream/x-fern-streaming-shared-schema", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "inlinedRequestBody", + "name": "StreamXFernStreamingSharedSchemaRequest", + "extends": [], + "properties": [ + { + "name": "prompt", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The prompt to complete." + }, + { + "name": "model", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The model to use." + }, + { + "name": "stream", + "valueType": { + "_type": "container", + "container": { + "_type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "Whether to stream the response." + } + ], + "extra-properties": false, + "extendedProperties": [], + "docs": null, + "v2Examples": null, + "contentType": "application/json" + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "wrapper", + "wrapperName": "StreamXFernStreamingSharedSchemaRequest", + "bodyKey": "body", + "includePathParameters": false, + "onlyPathParameters": false + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "json", + "value": { + "type": "response", + "responseBodyType": { + "_type": "named", + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse", + "default": null, + "inline": null + }, + "docs": "", + "v2Examples": null + } + }, + "status-code": 200, + "isWildcardStatusCode": null, + "docs": "" + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "315b1ff0", + "name": null, + "url": "/stream/x-fern-streaming-shared-schema", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "prompt", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + }, + "originalTypeDeclaration": null + }, + { + "name": "model", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "model" + } + } + }, + "jsonExample": "model" + }, + "originalTypeDeclaration": null + }, + { + "name": "stream", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "jsonExample": false + }, + "originalTypeDeclaration": null + } + ], + "extraProperties": null, + "jsonExample": { + "prompt": "prompt", + "model": "model", + "stream": false + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponseFinishReason", + "displayName": null + }, + "shape": { + "type": "enum", + "value": "complete" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "671f7c13", + "url": "/stream/x-fern-streaming-shared-schema", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "prompt", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + } + }, + { + "name": "model", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "model" + } + } + }, + "jsonExample": "model" + } + }, + { + "name": "stream", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "jsonExample": false + } + } + ], + "extraProperties": null, + "jsonExample": { + "prompt": "prompt", + "model": "model", + "stream": false + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "shape": { + "type": "enum", + "value": "complete" + }, + "typeName": { + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing." + }, + { + "id": "endpoint_.validateCompletion", + "name": "validateCompletion", + "displayName": "Non-streaming endpoint sharing request schema with endpoint 10", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/validate-completion", + "parts": [] + }, + "fullPath": { + "head": "validate-completion", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "inlinedRequestBody", + "name": "SharedCompletionRequest", + "extends": [], + "properties": [ + { + "name": "prompt", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The prompt to complete." + }, + { + "name": "model", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The model to use." + }, + { + "name": "stream", + "valueType": { + "_type": "container", + "container": { + "_type": "optional", + "optional": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": null + } + } + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "Whether to stream the response." + } + ], + "extra-properties": false, + "extendedProperties": [], + "docs": null, + "v2Examples": null, + "contentType": "application/json" + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "wrapper", + "wrapperName": "SharedCompletionRequest", + "bodyKey": "body", + "includePathParameters": false, + "onlyPathParameters": false + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "json", + "value": { + "type": "response", + "responseBodyType": { + "_type": "named", + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse", + "default": null, + "inline": null + }, + "docs": "Validation result", + "v2Examples": null + } + }, + "status-code": 200, + "isWildcardStatusCode": null, + "docs": "Validation result" + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "6a25fad5", + "name": null, + "url": "/validate-completion", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "prompt", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + }, + "originalTypeDeclaration": null + }, + { + "name": "model", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "model" + } + } + }, + "jsonExample": "model" + }, + "originalTypeDeclaration": null + } + ], + "extraProperties": null, + "jsonExample": { + "prompt": "prompt", + "model": "model" + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponseFinishReason", + "displayName": null + }, + "shape": { + "type": "enum", + "value": "complete" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "b9428f5d", + "url": "/validate-completion", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "prompt", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + } + }, + { + "name": "model", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "model" + } + } + }, + "jsonExample": "model" + } + }, + { + "name": "stream", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": null, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": null + } + } + } + } + } + } + } + ], + "extraProperties": null, + "jsonExample": { + "prompt": "prompt", + "model": "model" + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "shape": { + "type": "enum", + "value": "complete" + }, + "typeName": { + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "A non-streaming endpoint that references the same SharedCompletionRequest schema as endpoint 10. Ensures the shared $ref schema remains available and is not excluded during the streaming endpoint's processing." + }, + { + "id": "endpoint_.streamXFernStreamingUnion_stream", + "name": "streamXFernStreamingUnion_stream", + "displayName": "x-fern-streaming with discriminated union request body", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/x-fern-streaming-union", + "parts": [] + }, + "fullPath": { + "head": "stream/x-fern-streaming-union", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "reference", + "requestBodyType": { + "_type": "named", + "name": "StreamXFernStreamingUnionStreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamXFernStreamingUnionStreamRequest", + "default": null, + "inline": null + }, + "docs": "A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict.", + "contentType": "application/json", + "v2Examples": null + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "justRequestBody", + "value": { + "type": "typeReference", + "requestBodyType": { + "_type": "named", + "name": "StreamXFernStreamingUnionStreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamXFernStreamingUnionStreamRequest", + "default": null, + "inline": null + }, + "docs": "A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict.", + "contentType": null, + "v2Examples": null + } + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "streaming", + "value": { + "type": "json", + "payload": { + "_type": "named", + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk", + "default": null, + "inline": null + }, + "terminator": null, + "docs": "", + "v2Examples": null + } + }, + "status-code": null, + "isWildcardStatusCode": null, + "docs": null + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "2f5b7571", + "name": null, + "url": "/stream/x-fern-streaming-union", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:StreamXFernStreamingUnionStreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "StreamXFernStreamingUnionStreamRequest", + "displayName": null + }, + "shape": { + "type": "union", + "discriminant": "type", + "singleUnionType": { + "wireDiscriminantValue": "message", + "shape": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "object": { + "properties": [ + { + "name": "prompt", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + }, + "originalTypeDeclaration": { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + }, + "propertyAccess": null + }, + { + "name": "message", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "message" + } + } + }, + "jsonExample": "message" + }, + "originalTypeDeclaration": { + "typeId": "type_:UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "UnionStreamMessageVariant", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "stream_response", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "boolean", + "boolean": true + } + }, + "jsonExample": true + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": null + } + } + } + } + }, + "jsonExample": true + }, + "originalTypeDeclaration": { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + } + }, + "baseProperties": [ + { + "name": "stream_response", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "jsonExample": true + } + } + ], + "extendProperties": [] + } + }, + "jsonExample": { + "prompt": "prompt", + "message": "message", + "type": "message", + "stream_response": true + } + }, + "response": { + "type": "ok", + "value": { + "type": "stream", + "value": [ + { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "delta", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "delta" + } + } + }, + "jsonExample": "delta" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "delta" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "tokens", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": 1 + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "delta": "delta", + "tokens": 1 + } + } + ] + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "85ce00e4", + "url": "/stream/x-fern-streaming-union", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "shape": { + "type": "union", + "discriminant": "type", + "singleUnionType": { + "wireDiscriminantValue": "message", + "shape": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "object": { + "properties": [ + { + "name": "message", + "originalTypeDeclaration": { + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "message" + } + } + }, + "jsonExample": "message" + }, + "propertyAccess": null + }, + { + "name": "stream_response", + "originalTypeDeclaration": { + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": null, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": false + } + } + } + } + } + }, + "propertyAccess": null + }, + { + "name": "prompt", + "originalTypeDeclaration": { + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + } + }, + "baseProperties": [ + { + "name": "stream_response", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "jsonExample": true + } + } + ], + "extendProperties": [] + }, + "typeName": { + "name": "StreamXFernStreamingUnionStreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamXFernStreamingUnionStreamRequest" + } + }, + "jsonExample": { + "type": "message", + "message": "message", + "stream_response": true, + "prompt": "prompt" + } + }, + "response": { + "type": "ok", + "value": { + "type": "stream", + "value": [ + { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "delta", + "originalTypeDeclaration": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "delta" + } + } + }, + "jsonExample": "delta" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "delta" + }, + "propertyAccess": null + }, + { + "name": "tokens", + "originalTypeDeclaration": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": 1 + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + } + }, + "jsonExample": { + "delta": "delta", + "tokens": 1 + } + } + ] + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant." + }, + { + "id": "endpoint_.streamXFernStreamingUnion", + "name": "streamXFernStreamingUnion", + "displayName": "x-fern-streaming with discriminated union request body", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/x-fern-streaming-union", + "parts": [] + }, + "fullPath": { + "head": "stream/x-fern-streaming-union", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "reference", + "requestBodyType": { + "_type": "named", + "name": "StreamXFernStreamingUnionRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamXFernStreamingUnionRequest", + "default": null, + "inline": null + }, + "docs": "A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict.", + "contentType": "application/json", + "v2Examples": null + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "justRequestBody", + "value": { + "type": "typeReference", + "requestBodyType": { + "_type": "named", + "name": "StreamXFernStreamingUnionRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamXFernStreamingUnionRequest", + "default": null, + "inline": null + }, + "docs": "A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict.", + "contentType": null, + "v2Examples": null + } + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "json", + "value": { + "type": "response", + "responseBodyType": { + "_type": "named", + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse", + "default": null, + "inline": null + }, + "docs": "", + "v2Examples": null + } + }, + "status-code": 200, + "isWildcardStatusCode": null, + "docs": "" + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "84e9dacd", + "name": null, + "url": "/stream/x-fern-streaming-union", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:StreamXFernStreamingUnionRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "StreamXFernStreamingUnionRequest", + "displayName": null + }, + "shape": { + "type": "union", + "discriminant": "type", + "singleUnionType": { + "wireDiscriminantValue": "message", + "shape": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "object": { + "properties": [ + { + "name": "prompt", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + }, + "originalTypeDeclaration": { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + }, + "propertyAccess": null + }, + { + "name": "message", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "message" + } + } + }, + "jsonExample": "message" + }, + "originalTypeDeclaration": { + "typeId": "type_:UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "UnionStreamMessageVariant", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "stream_response", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "boolean", + "boolean": false + } + }, + "jsonExample": false + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": null + } + } + } + } + }, + "jsonExample": false + }, + "originalTypeDeclaration": { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + } + }, + "baseProperties": [ + { + "name": "stream_response", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "jsonExample": false + } + } + ], + "extendProperties": [] + } + }, + "jsonExample": { + "prompt": "prompt", + "message": "message", + "type": "message", + "stream_response": false + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponseFinishReason", + "displayName": null + }, + "shape": { + "type": "enum", + "value": "complete" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "f9bb39e2", + "url": "/stream/x-fern-streaming-union", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "shape": { + "type": "union", + "discriminant": "type", + "singleUnionType": { + "wireDiscriminantValue": "message", + "shape": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "object": { + "properties": [ + { + "name": "message", + "originalTypeDeclaration": { + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "message" + } + } + }, + "jsonExample": "message" + }, + "propertyAccess": null + }, + { + "name": "stream_response", + "originalTypeDeclaration": { + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": null, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": false + } + } + } + } + } + }, + "propertyAccess": null + }, + { + "name": "prompt", + "originalTypeDeclaration": { + "name": "UnionStreamMessageVariant", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamMessageVariant" + }, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + } + }, + "baseProperties": [ + { + "name": "stream_response", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "jsonExample": false + } + } + ], + "extendProperties": [] + }, + "typeName": { + "name": "StreamXFernStreamingUnionRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamXFernStreamingUnionRequest" + } + }, + "jsonExample": { + "type": "message", + "message": "message", + "stream_response": false, + "prompt": "prompt" + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "shape": { + "type": "enum", + "value": "complete" + }, + "typeName": { + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant." + }, + { + "id": "endpoint_.validateUnionRequest", + "name": "validateUnionRequest", + "displayName": "Non-streaming endpoint referencing the union base schema", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/validate-union-request", + "parts": [] + }, + "fullPath": { + "head": "validate-union-request", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "reference", + "requestBodyType": { + "_type": "named", + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase", + "default": null, + "inline": null + }, + "docs": null, + "contentType": "application/json", + "v2Examples": null + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "justRequestBody", + "value": { + "type": "typeReference", + "requestBodyType": { + "_type": "named", + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase", + "default": null, + "inline": null + }, + "docs": null, + "contentType": null, + "v2Examples": null + } + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "json", + "value": { + "type": "response", + "responseBodyType": { + "_type": "named", + "name": "ValidateUnionRequestResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:ValidateUnionRequestResponse", + "default": null, + "inline": null + }, + "docs": "Validation result", + "v2Examples": null + } + }, + "status-code": 200, + "isWildcardStatusCode": null, + "docs": "Validation result" + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "56a45a69", + "name": null, + "url": "/validate-union-request", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "UnionStreamRequestBase", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "prompt", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + }, + "originalTypeDeclaration": { + "typeId": "type_:UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "UnionStreamRequestBase", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "prompt": "prompt" + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:ValidateUnionRequestResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "ValidateUnionRequestResponse", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "valid", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "boolean", + "boolean": true + } + }, + "jsonExample": true + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": null + } + } + } + } + }, + "jsonExample": true + }, + "originalTypeDeclaration": { + "typeId": "type_:ValidateUnionRequestResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "ValidateUnionRequestResponse", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "valid": true + } + } + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "4885f865", + "url": "/validate-union-request", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "stream_response", + "originalTypeDeclaration": { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": null, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": false + } + } + } + } + } + }, + "propertyAccess": null + }, + { + "name": "prompt", + "originalTypeDeclaration": { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + }, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "prompt" + } + } + }, + "jsonExample": "prompt" + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "UnionStreamRequestBase", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:UnionStreamRequestBase" + } + }, + "jsonExample": { + "prompt": "prompt" + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "valid", + "originalTypeDeclaration": { + "name": "ValidateUnionRequestResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:ValidateUnionRequestResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "boolean", + "boolean": true + } + }, + "jsonExample": true + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "BOOLEAN", + "v2": { + "type": "boolean", + "default": null + } + } + } + } + }, + "jsonExample": true + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "ValidateUnionRequestResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:ValidateUnionRequestResponse" + } + }, + "jsonExample": { + "valid": true + } + } + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "References UnionStreamRequestBase directly, ensuring the base schema cannot be excluded from the context. This endpoint exists to verify that shared base schemas used in discriminated union variants with stream-condition remain available." + }, + { + "id": "endpoint_.streamXFernStreamingNullableCondition_stream", + "name": "streamXFernStreamingNullableCondition_stream", + "displayName": "x-fern-streaming with nullable stream condition field", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/x-fern-streaming-nullable-condition", + "parts": [] + }, + "fullPath": { + "head": "stream/x-fern-streaming-nullable-condition", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "inlinedRequestBody", + "name": "StreamXFernStreamingNullableConditionStreamRequest", + "extends": [], + "properties": [ + { + "name": "query", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The prompt or query to complete." + }, + { + "name": "stream", + "valueType": { + "_type": "container", + "container": { + "_type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "Whether to stream the response. This field is nullable (OAS 3.1 type array), which previously caused the const literal to be overwritten by the nullable type during spread in the importer." + } + ], + "extra-properties": false, + "extendedProperties": [], + "docs": null, + "v2Examples": null, + "contentType": "application/json" + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "wrapper", + "wrapperName": "StreamXFernStreamingNullableConditionStreamRequest", + "bodyKey": "body", + "includePathParameters": false, + "onlyPathParameters": false + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "streaming", + "value": { + "type": "json", + "payload": { + "_type": "named", + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk", + "default": null, + "inline": null + }, + "terminator": null, + "docs": "", + "v2Examples": null + } + }, + "status-code": null, + "isWildcardStatusCode": null, + "docs": null + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "9e6c48a6", + "name": null, + "url": "/stream/x-fern-streaming-nullable-condition", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "query", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "query" + } + } + }, + "jsonExample": "query" + }, + "originalTypeDeclaration": null + }, + { + "name": "stream", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "jsonExample": true + }, + "originalTypeDeclaration": null + } + ], + "extraProperties": null, + "jsonExample": { + "query": "query", + "stream": true + } + }, + "response": { + "type": "ok", + "value": { + "type": "stream", + "value": [ + { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "delta", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "delta" + } + } + }, + "jsonExample": "delta" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "delta" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "tokens", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": 1 + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionStreamChunk", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "delta": "delta", + "tokens": 1 + } + } + ] + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "fbda279e", + "url": "/stream/x-fern-streaming-nullable-condition", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "query", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "query" + } + } + }, + "jsonExample": "query" + } + }, + { + "name": "stream", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": true + } + } + }, + "jsonExample": true + } + } + ], + "extraProperties": null, + "jsonExample": { + "query": "query", + "stream": true + } + }, + "response": { + "type": "ok", + "value": { + "type": "stream", + "value": [ + { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "delta", + "originalTypeDeclaration": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "delta" + } + } + }, + "jsonExample": "delta" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "delta" + }, + "propertyAccess": null + }, + { + "name": "tokens", + "originalTypeDeclaration": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "integer", + "integer": 1 + } + }, + "jsonExample": 1 + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "INTEGER", + "v2": { + "type": "integer", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": 1 + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "CompletionStreamChunk", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionStreamChunk" + } + }, + "jsonExample": { + "delta": "delta", + "tokens": 1 + } + } + ] + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Uses x-fern-streaming with stream-condition where the stream field is nullable (type: [\"boolean\", \"null\"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property." + }, + { + "id": "endpoint_.streamXFernStreamingNullableCondition", + "name": "streamXFernStreamingNullableCondition", + "displayName": "x-fern-streaming with nullable stream condition field", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/x-fern-streaming-nullable-condition", + "parts": [] + }, + "fullPath": { + "head": "stream/x-fern-streaming-nullable-condition", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "inlinedRequestBody", + "name": "StreamXFernStreamingNullableConditionRequest", + "extends": [], + "properties": [ + { + "name": "query", + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "The prompt or query to complete." + }, + { + "name": "stream", + "valueType": { + "_type": "container", + "container": { + "_type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "v2Examples": { + "userSpecifiedExamples": {}, + "autogeneratedExamples": {} + }, + "propertyAccess": null, + "availability": null, + "docs": "Whether to stream the response. This field is nullable (OAS 3.1 type array), which previously caused the const literal to be overwritten by the nullable type during spread in the importer." + } + ], + "extra-properties": false, + "extendedProperties": [], + "docs": null, + "v2Examples": null, + "contentType": "application/json" + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "wrapper", + "wrapperName": "StreamXFernStreamingNullableConditionRequest", + "bodyKey": "body", + "includePathParameters": false, + "onlyPathParameters": false + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "json", + "value": { + "type": "response", + "responseBodyType": { + "_type": "named", + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse", + "default": null, + "inline": null + }, + "docs": "", + "v2Examples": null + } + }, + "status-code": 200, + "isWildcardStatusCode": null, + "docs": "" + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "a81f32a2", + "name": null, + "url": "/stream/x-fern-streaming-nullable-condition", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "query", + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "query" + } + } + }, + "jsonExample": "query" + }, + "originalTypeDeclaration": null + }, + { + "name": "stream", + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "jsonExample": false + }, + "originalTypeDeclaration": null + } + ], + "extraProperties": null, + "jsonExample": { + "query": "query", + "stream": false + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponseFinishReason", + "displayName": null + }, + "shape": { + "type": "enum", + "value": "complete" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "originalTypeDeclaration": { + "typeId": "type_:CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "CompletionFullResponse", + "displayName": null + }, + "propertyAccess": null + } + ], + "extraProperties": null + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "f103dbd8", + "url": "/stream/x-fern-streaming-nullable-condition", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "inlinedRequestBody", + "properties": [ + { + "name": "query", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "query" + } + } + }, + "jsonExample": "query" + } + }, + { + "name": "stream", + "originalTypeDeclaration": null, + "value": { + "shape": { + "type": "container", + "container": { + "type": "literal", + "literal": { + "type": "boolean", + "boolean": false + } + } + }, + "jsonExample": false + } + } + ], + "extraProperties": null, + "jsonExample": { + "query": "query", + "stream": false + } + }, + "response": { + "type": "ok", + "value": { + "type": "body", + "value": { + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "answer", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "answer" + } + } + }, + "jsonExample": "answer" + }, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + }, + "jsonExample": "answer" + }, + "propertyAccess": null + }, + { + "name": "finishReason", + "originalTypeDeclaration": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": { + "shape": { + "type": "named", + "shape": { + "type": "enum", + "value": "complete" + }, + "typeName": { + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason" + } + }, + "jsonExample": "complete" + }, + "valueType": { + "_type": "named", + "name": "CompletionFullResponseFinishReason", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponseFinishReason", + "default": null, + "inline": null + } + } + }, + "jsonExample": "complete" + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "CompletionFullResponse", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:CompletionFullResponse" + } + }, + "jsonExample": { + "answer": "answer", + "finishReason": "complete" + } + } + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Uses x-fern-streaming with stream-condition where the stream field is nullable (type: [\"boolean\", \"null\"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property." + }, + { + "id": "endpoint_.streamXFernStreamingSseOnly", + "name": "streamXFernStreamingSseOnly", + "displayName": "x-fern-streaming with SSE format but no stream-condition", + "auth": false, + "security": null, + "idempotent": false, + "baseUrl": null, + "v2BaseUrls": null, + "method": "POST", + "basePath": null, + "path": { + "head": "/stream/x-fern-streaming-sse-only", + "parts": [] + }, + "fullPath": { + "head": "stream/x-fern-streaming-sse-only", + "parts": [] + }, + "pathParameters": [], + "allPathParameters": [], + "queryParameters": [], + "headers": [], + "requestBody": { + "type": "reference", + "requestBodyType": { + "_type": "named", + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest", + "default": null, + "inline": null + }, + "docs": null, + "contentType": "application/json", + "v2Examples": null + }, + "v2RequestBodies": null, + "sdkRequest": { + "shape": { + "type": "justRequestBody", + "value": { + "type": "typeReference", + "requestBodyType": { + "_type": "named", + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest", + "default": null, + "inline": null + }, + "docs": null, + "contentType": null, + "v2Examples": null + } + }, + "requestParameterName": "request", + "streamParameter": null + }, + "response": { + "body": { + "type": "streaming", + "value": { + "type": "sse", + "payload": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + }, + "terminator": null, + "docs": "SSE stream of completion chunks", + "v2Examples": null + } + }, + "status-code": null, + "isWildcardStatusCode": null, + "docs": null + }, + "v2Responses": null, + "errors": [], + "userSpecifiedExamples": [ + { + "example": { + "id": "6a4b64c4", + "name": null, + "url": "/stream/x-fern-streaming-sse-only", + "rootPathParameters": [], + "endpointPathParameters": [], + "servicePathParameters": [], + "endpointHeaders": [], + "serviceHeaders": [], + "queryParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "typeName": { + "typeId": "type_:StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "name": "StreamRequest", + "displayName": null + }, + "shape": { + "type": "object", + "properties": [], + "extraProperties": null + } + }, + "jsonExample": {} + }, + "response": { + "type": "ok", + "value": { + "type": "sse", + "value": [ + { + "event": "", + "data": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "string" + } + } + }, + "jsonExample": "string" + } + } + ] + } + }, + "docs": null + }, + "codeSamples": null + } + ], + "autogeneratedExamples": [ + { + "example": { + "id": "565554b3", + "url": "/stream/x-fern-streaming-sse-only", + "name": null, + "endpointHeaders": [], + "endpointPathParameters": [], + "queryParameters": [], + "servicePathParameters": [], + "serviceHeaders": [], + "rootPathParameters": [], + "request": { + "type": "reference", + "shape": { + "type": "named", + "shape": { + "type": "object", + "properties": [ + { + "name": "query", + "originalTypeDeclaration": { + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest" + }, + "value": { + "shape": { + "type": "container", + "container": { + "type": "optional", + "optional": null, + "valueType": { + "_type": "primitive", + "primitive": { + "v1": "STRING", + "v2": { + "type": "string", + "default": null, + "validation": null + } + } + } + } + } + }, + "propertyAccess": null + } + ], + "extraProperties": null + }, + "typeName": { + "name": "StreamRequest", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + }, + "displayName": null, + "typeId": "type_:StreamRequest" + } + }, + "jsonExample": {} + }, + "response": { + "type": "ok", + "value": { + "type": "sse", + "value": [ + { + "data": { + "shape": { + "type": "primitive", + "primitive": { + "type": "string", + "string": { + "original": "string" + } + } + }, + "jsonExample": "string" + }, + "event": "" + } + ] + } + }, + "docs": null + } + } + ], + "pagination": null, + "transport": null, + "v2Examples": null, + "source": null, + "audiences": null, + "retries": null, + "apiPlayground": null, + "responseHeaders": [], + "availability": null, + "docs": "Uses x-fern-streaming with format: sse but no stream-condition. This represents a stream-only endpoint that always returns SSE. There is no non-streaming variant, and the response is always a stream of chunks." + } + ], + "audiences": null + } + }, + "constants": { + "errorInstanceIdKey": "errorInstanceId" + }, + "environments": null, + "errorDiscriminationStrategy": { + "type": "statusCode" + }, + "basePath": null, + "pathParameters": [], + "variables": [], + "serviceTypeReferenceInfo": { + "typesReferencedOnlyByService": { + "service_": [ + "type_:StreamProtocolNoCollisionResponse", + "type_:StreamProtocolCollisionResponse", + "type_:StreamDataContextResponse", + "type_:StreamNoContextResponse", + "type_:StreamProtocolWithFlatSchemaResponse", + "type_:StreamDataContextWithEnvelopeSchemaResponse", + "type_:StreamXFernStreamingUnionStreamRequest", + "type_:StreamXFernStreamingUnionRequest", + "type_:ValidateUnionRequestResponse", + "type_:StreamRequest", + "type_:Event", + "type_:StatusPayload", + "type_:ObjectPayloadWithEventField", + "type_:HeartbeatPayload", + "type_:EntityEventPayloadEventType", + "type_:EntityEventPayload", + "type_:ProtocolHeartbeat", + "type_:ProtocolStringEvent", + "type_:ProtocolNumberEvent", + "type_:ProtocolObjectEvent", + "type_:ProtocolCollisionObjectEvent", + "type_:DataContextHeartbeat", + "type_:DataContextEntityEvent", + "type_:CompletionFullResponseFinishReason", + "type_:CompletionFullResponse", + "type_:CompletionStreamChunk", + "type_:UnionStreamRequestBase", + "type_:UnionStreamMessageVariant", + "type_:UnionStreamInterruptVariant", + "type_:UnionStreamCompactVariant" + ] + }, + "sharedTypes": [ + "type_:CompletionRequest", + "type_:NullableStreamRequest", + "type_:UnionStreamRequest" + ] + }, + "webhookGroups": {}, + "websocketChannels": {}, + "readmeConfig": null, + "sourceConfig": null, + "publishConfig": null, + "dynamic": { + "version": "1.0.0", + "types": { + "type_:StreamProtocolNoCollisionResponse": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamProtocolNoCollisionResponse", + "camelCase": { + "unsafeName": "streamProtocolNoCollisionResponse", + "safeName": "streamProtocolNoCollisionResponse" + }, + "snakeCase": { + "unsafeName": "stream_protocol_no_collision_response", + "safeName": "stream_protocol_no_collision_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_PROTOCOL_NO_COLLISION_RESPONSE", + "safeName": "STREAM_PROTOCOL_NO_COLLISION_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamProtocolNoCollisionResponse", + "safeName": "StreamProtocolNoCollisionResponse" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "event", + "name": { + "originalName": "event", + "camelCase": { + "unsafeName": "event", + "safeName": "event" + }, + "snakeCase": { + "unsafeName": "event", + "safeName": "event" + }, + "screamingSnakeCase": { + "unsafeName": "EVENT", + "safeName": "EVENT" + }, + "pascalCase": { + "unsafeName": "Event", + "safeName": "Event" + } + } + }, + "types": { + "heartbeat": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolHeartbeat", + "discriminantValue": { + "wireValue": "heartbeat", + "name": { + "originalName": "heartbeat", + "camelCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "snakeCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "screamingSnakeCase": { + "unsafeName": "HEARTBEAT", + "safeName": "HEARTBEAT" + }, + "pascalCase": { + "unsafeName": "Heartbeat", + "safeName": "Heartbeat" + } + } + }, + "properties": [] + }, + "string_data": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolStringEvent", + "discriminantValue": { + "wireValue": "string_data", + "name": { + "originalName": "string_data", + "camelCase": { + "unsafeName": "stringData", + "safeName": "stringData" + }, + "snakeCase": { + "unsafeName": "string_data", + "safeName": "string_data" + }, + "screamingSnakeCase": { + "unsafeName": "STRING_DATA", + "safeName": "STRING_DATA" + }, + "pascalCase": { + "unsafeName": "StringData", + "safeName": "StringData" + } + } + }, + "properties": [] + }, + "number_data": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolNumberEvent", + "discriminantValue": { + "wireValue": "number_data", + "name": { + "originalName": "number_data", + "camelCase": { + "unsafeName": "numberData", + "safeName": "numberData" + }, + "snakeCase": { + "unsafeName": "number_data", + "safeName": "number_data" + }, + "screamingSnakeCase": { + "unsafeName": "NUMBER_DATA", + "safeName": "NUMBER_DATA" + }, + "pascalCase": { + "unsafeName": "NumberData", + "safeName": "NumberData" + } + } + }, + "properties": [] + }, + "object_data": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolObjectEvent", + "discriminantValue": { + "wireValue": "object_data", + "name": { + "originalName": "object_data", + "camelCase": { + "unsafeName": "objectData", + "safeName": "objectData" + }, + "snakeCase": { + "unsafeName": "object_data", + "safeName": "object_data" + }, + "screamingSnakeCase": { + "unsafeName": "OBJECT_DATA", + "safeName": "OBJECT_DATA" + }, + "pascalCase": { + "unsafeName": "ObjectData", + "safeName": "ObjectData" + } + } + }, + "properties": [] + } + } + }, + "type_:StreamProtocolCollisionResponse": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamProtocolCollisionResponse", + "camelCase": { + "unsafeName": "streamProtocolCollisionResponse", + "safeName": "streamProtocolCollisionResponse" + }, + "snakeCase": { + "unsafeName": "stream_protocol_collision_response", + "safeName": "stream_protocol_collision_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_PROTOCOL_COLLISION_RESPONSE", + "safeName": "STREAM_PROTOCOL_COLLISION_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamProtocolCollisionResponse", + "safeName": "StreamProtocolCollisionResponse" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "event", + "name": { + "originalName": "event", + "camelCase": { + "unsafeName": "event", + "safeName": "event" + }, + "snakeCase": { + "unsafeName": "event", + "safeName": "event" + }, + "screamingSnakeCase": { + "unsafeName": "EVENT", + "safeName": "EVENT" + }, + "pascalCase": { + "unsafeName": "Event", + "safeName": "Event" + } + } + }, + "types": { + "heartbeat": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolHeartbeat", + "discriminantValue": { + "wireValue": "heartbeat", + "name": { + "originalName": "heartbeat", + "camelCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "snakeCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "screamingSnakeCase": { + "unsafeName": "HEARTBEAT", + "safeName": "HEARTBEAT" + }, + "pascalCase": { + "unsafeName": "Heartbeat", + "safeName": "Heartbeat" + } + } + }, + "properties": [] + }, + "string_data": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolStringEvent", + "discriminantValue": { + "wireValue": "string_data", + "name": { + "originalName": "string_data", + "camelCase": { + "unsafeName": "stringData", + "safeName": "stringData" + }, + "snakeCase": { + "unsafeName": "string_data", + "safeName": "string_data" + }, + "screamingSnakeCase": { + "unsafeName": "STRING_DATA", + "safeName": "STRING_DATA" + }, + "pascalCase": { + "unsafeName": "StringData", + "safeName": "StringData" + } + } + }, + "properties": [] + }, + "number_data": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolNumberEvent", + "discriminantValue": { + "wireValue": "number_data", + "name": { + "originalName": "number_data", + "camelCase": { + "unsafeName": "numberData", + "safeName": "numberData" + }, + "snakeCase": { + "unsafeName": "number_data", + "safeName": "number_data" + }, + "screamingSnakeCase": { + "unsafeName": "NUMBER_DATA", + "safeName": "NUMBER_DATA" + }, + "pascalCase": { + "unsafeName": "NumberData", + "safeName": "NumberData" + } + } + }, + "properties": [] + }, + "object_data": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolCollisionObjectEvent", + "discriminantValue": { + "wireValue": "object_data", + "name": { + "originalName": "object_data", + "camelCase": { + "unsafeName": "objectData", + "safeName": "objectData" + }, + "snakeCase": { + "unsafeName": "object_data", + "safeName": "object_data" + }, + "screamingSnakeCase": { + "unsafeName": "OBJECT_DATA", + "safeName": "OBJECT_DATA" + }, + "pascalCase": { + "unsafeName": "ObjectData", + "safeName": "ObjectData" + } + } + }, + "properties": [] + } + } + }, + "type_:StreamDataContextResponse": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamDataContextResponse", + "camelCase": { + "unsafeName": "streamDataContextResponse", + "safeName": "streamDataContextResponse" + }, + "snakeCase": { + "unsafeName": "stream_data_context_response", + "safeName": "stream_data_context_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_DATA_CONTEXT_RESPONSE", + "safeName": "STREAM_DATA_CONTEXT_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamDataContextResponse", + "safeName": "StreamDataContextResponse" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "event", + "name": { + "originalName": "event", + "camelCase": { + "unsafeName": "event", + "safeName": "event" + }, + "snakeCase": { + "unsafeName": "event", + "safeName": "event" + }, + "screamingSnakeCase": { + "unsafeName": "EVENT", + "safeName": "EVENT" + }, + "pascalCase": { + "unsafeName": "Event", + "safeName": "Event" + } + } + }, + "types": { + "heartbeat": { + "type": "samePropertiesAsObject", + "typeId": "type_:DataContextHeartbeat", + "discriminantValue": { + "wireValue": "heartbeat", + "name": { + "originalName": "heartbeat", + "camelCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "snakeCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "screamingSnakeCase": { + "unsafeName": "HEARTBEAT", + "safeName": "HEARTBEAT" + }, + "pascalCase": { + "unsafeName": "Heartbeat", + "safeName": "Heartbeat" + } + } + }, + "properties": [] + }, + "entity": { + "type": "samePropertiesAsObject", + "typeId": "type_:DataContextEntityEvent", + "discriminantValue": { + "wireValue": "entity", + "name": { + "originalName": "entity", + "camelCase": { + "unsafeName": "entity", + "safeName": "entity" + }, + "snakeCase": { + "unsafeName": "entity", + "safeName": "entity" + }, + "screamingSnakeCase": { + "unsafeName": "ENTITY", + "safeName": "ENTITY" + }, + "pascalCase": { + "unsafeName": "Entity", + "safeName": "Entity" + } + } + }, + "properties": [] + } + } + }, + "type_:StreamNoContextResponse": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamNoContextResponse", + "camelCase": { + "unsafeName": "streamNoContextResponse", + "safeName": "streamNoContextResponse" + }, + "snakeCase": { + "unsafeName": "stream_no_context_response", + "safeName": "stream_no_context_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_NO_CONTEXT_RESPONSE", + "safeName": "STREAM_NO_CONTEXT_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamNoContextResponse", + "safeName": "StreamNoContextResponse" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "event", + "name": { + "originalName": "event", + "camelCase": { + "unsafeName": "event", + "safeName": "event" + }, + "snakeCase": { + "unsafeName": "event", + "safeName": "event" + }, + "screamingSnakeCase": { + "unsafeName": "EVENT", + "safeName": "EVENT" + }, + "pascalCase": { + "unsafeName": "Event", + "safeName": "Event" + } + } + }, + "types": { + "heartbeat": { + "type": "samePropertiesAsObject", + "typeId": "type_:DataContextHeartbeat", + "discriminantValue": { + "wireValue": "heartbeat", + "name": { + "originalName": "heartbeat", + "camelCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "snakeCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "screamingSnakeCase": { + "unsafeName": "HEARTBEAT", + "safeName": "HEARTBEAT" + }, + "pascalCase": { + "unsafeName": "Heartbeat", + "safeName": "Heartbeat" + } + } + }, + "properties": [] + }, + "entity": { + "type": "samePropertiesAsObject", + "typeId": "type_:DataContextEntityEvent", + "discriminantValue": { + "wireValue": "entity", + "name": { + "originalName": "entity", + "camelCase": { + "unsafeName": "entity", + "safeName": "entity" + }, + "snakeCase": { + "unsafeName": "entity", + "safeName": "entity" + }, + "screamingSnakeCase": { + "unsafeName": "ENTITY", + "safeName": "ENTITY" + }, + "pascalCase": { + "unsafeName": "Entity", + "safeName": "Entity" + } + } + }, + "properties": [] + } + } + }, + "type_:StreamProtocolWithFlatSchemaResponse": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamProtocolWithFlatSchemaResponse", + "camelCase": { + "unsafeName": "streamProtocolWithFlatSchemaResponse", + "safeName": "streamProtocolWithFlatSchemaResponse" + }, + "snakeCase": { + "unsafeName": "stream_protocol_with_flat_schema_response", + "safeName": "stream_protocol_with_flat_schema_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA_RESPONSE", + "safeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamProtocolWithFlatSchemaResponse", + "safeName": "StreamProtocolWithFlatSchemaResponse" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "event", + "name": { + "originalName": "event", + "camelCase": { + "unsafeName": "event", + "safeName": "event" + }, + "snakeCase": { + "unsafeName": "event", + "safeName": "event" + }, + "screamingSnakeCase": { + "unsafeName": "EVENT", + "safeName": "EVENT" + }, + "pascalCase": { + "unsafeName": "Event", + "safeName": "Event" + } + } + }, + "types": { + "heartbeat": { + "type": "samePropertiesAsObject", + "typeId": "type_:DataContextHeartbeat", + "discriminantValue": { + "wireValue": "heartbeat", + "name": { + "originalName": "heartbeat", + "camelCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "snakeCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "screamingSnakeCase": { + "unsafeName": "HEARTBEAT", + "safeName": "HEARTBEAT" + }, + "pascalCase": { + "unsafeName": "Heartbeat", + "safeName": "Heartbeat" + } + } + }, + "properties": [] + }, + "entity": { + "type": "samePropertiesAsObject", + "typeId": "type_:DataContextEntityEvent", + "discriminantValue": { + "wireValue": "entity", + "name": { + "originalName": "entity", + "camelCase": { + "unsafeName": "entity", + "safeName": "entity" + }, + "snakeCase": { + "unsafeName": "entity", + "safeName": "entity" + }, + "screamingSnakeCase": { + "unsafeName": "ENTITY", + "safeName": "ENTITY" + }, + "pascalCase": { + "unsafeName": "Entity", + "safeName": "Entity" + } + } + }, + "properties": [] + } + } + }, + "type_:StreamDataContextWithEnvelopeSchemaResponse": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamDataContextWithEnvelopeSchemaResponse", + "camelCase": { + "unsafeName": "streamDataContextWithEnvelopeSchemaResponse", + "safeName": "streamDataContextWithEnvelopeSchemaResponse" + }, + "snakeCase": { + "unsafeName": "stream_data_context_with_envelope_schema_response", + "safeName": "stream_data_context_with_envelope_schema_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA_RESPONSE", + "safeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamDataContextWithEnvelopeSchemaResponse", + "safeName": "StreamDataContextWithEnvelopeSchemaResponse" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "event", + "name": { + "originalName": "event", + "camelCase": { + "unsafeName": "event", + "safeName": "event" + }, + "snakeCase": { + "unsafeName": "event", + "safeName": "event" + }, + "screamingSnakeCase": { + "unsafeName": "EVENT", + "safeName": "EVENT" + }, + "pascalCase": { + "unsafeName": "Event", + "safeName": "Event" + } + } + }, + "types": { + "heartbeat": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolHeartbeat", + "discriminantValue": { + "wireValue": "heartbeat", + "name": { + "originalName": "heartbeat", + "camelCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "snakeCase": { + "unsafeName": "heartbeat", + "safeName": "heartbeat" + }, + "screamingSnakeCase": { + "unsafeName": "HEARTBEAT", + "safeName": "HEARTBEAT" + }, + "pascalCase": { + "unsafeName": "Heartbeat", + "safeName": "Heartbeat" + } + } + }, + "properties": [] + }, + "string_data": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolStringEvent", + "discriminantValue": { + "wireValue": "string_data", + "name": { + "originalName": "string_data", + "camelCase": { + "unsafeName": "stringData", + "safeName": "stringData" + }, + "snakeCase": { + "unsafeName": "string_data", + "safeName": "string_data" + }, + "screamingSnakeCase": { + "unsafeName": "STRING_DATA", + "safeName": "STRING_DATA" + }, + "pascalCase": { + "unsafeName": "StringData", + "safeName": "StringData" + } + } + }, + "properties": [] + }, + "number_data": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolNumberEvent", + "discriminantValue": { + "wireValue": "number_data", + "name": { + "originalName": "number_data", + "camelCase": { + "unsafeName": "numberData", + "safeName": "numberData" + }, + "snakeCase": { + "unsafeName": "number_data", + "safeName": "number_data" + }, + "screamingSnakeCase": { + "unsafeName": "NUMBER_DATA", + "safeName": "NUMBER_DATA" + }, + "pascalCase": { + "unsafeName": "NumberData", + "safeName": "NumberData" + } + } + }, + "properties": [] + }, + "object_data": { + "type": "samePropertiesAsObject", + "typeId": "type_:ProtocolObjectEvent", + "discriminantValue": { + "wireValue": "object_data", + "name": { + "originalName": "object_data", + "camelCase": { + "unsafeName": "objectData", + "safeName": "objectData" + }, + "snakeCase": { + "unsafeName": "object_data", + "safeName": "object_data" + }, + "screamingSnakeCase": { + "unsafeName": "OBJECT_DATA", + "safeName": "OBJECT_DATA" + }, + "pascalCase": { + "unsafeName": "ObjectData", + "safeName": "ObjectData" + } + } + }, + "properties": [] + } + } + }, + "type_:StreamXFernStreamingUnionStreamRequest": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingUnionStreamRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingUnionStreamRequest", + "safeName": "streamXFernStreamingUnionStreamRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_union_stream_request", + "safeName": "stream_x_fern_streaming_union_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_UNION_STREAM_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_UNION_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingUnionStreamRequest", + "safeName": "StreamXFernStreamingUnionStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "type", + "name": { + "originalName": "type", + "camelCase": { + "unsafeName": "type", + "safeName": "type" + }, + "snakeCase": { + "unsafeName": "type", + "safeName": "type" + }, + "screamingSnakeCase": { + "unsafeName": "TYPE", + "safeName": "TYPE" + }, + "pascalCase": { + "unsafeName": "Type", + "safeName": "Type" + } + } + }, + "types": { + "message": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "discriminantValue": { + "wireValue": "message", + "name": { + "originalName": "message", + "camelCase": { + "unsafeName": "message", + "safeName": "message" + }, + "snakeCase": { + "unsafeName": "message", + "safeName": "message" + }, + "screamingSnakeCase": { + "unsafeName": "MESSAGE", + "safeName": "MESSAGE" + }, + "pascalCase": { + "unsafeName": "Message", + "safeName": "Message" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "interrupt": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamInterruptVariant", + "discriminantValue": { + "wireValue": "interrupt", + "name": { + "originalName": "interrupt", + "camelCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "snakeCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "screamingSnakeCase": { + "unsafeName": "INTERRUPT", + "safeName": "INTERRUPT" + }, + "pascalCase": { + "unsafeName": "Interrupt", + "safeName": "Interrupt" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "compact": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamCompactVariant", + "discriminantValue": { + "wireValue": "compact", + "name": { + "originalName": "compact", + "camelCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "snakeCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "screamingSnakeCase": { + "unsafeName": "COMPACT", + "safeName": "COMPACT" + }, + "pascalCase": { + "unsafeName": "Compact", + "safeName": "Compact" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + } + } + }, + "type_:StreamXFernStreamingUnionRequest": { + "type": "discriminatedUnion", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingUnionRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingUnionRequest", + "safeName": "streamXFernStreamingUnionRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_union_request", + "safeName": "stream_x_fern_streaming_union_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_UNION_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_UNION_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingUnionRequest", + "safeName": "StreamXFernStreamingUnionRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "discriminant": { + "wireValue": "type", + "name": { + "originalName": "type", + "camelCase": { + "unsafeName": "type", + "safeName": "type" + }, + "snakeCase": { + "unsafeName": "type", + "safeName": "type" + }, + "screamingSnakeCase": { + "unsafeName": "TYPE", + "safeName": "TYPE" + }, + "pascalCase": { + "unsafeName": "Type", + "safeName": "Type" + } + } + }, + "types": { + "message": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "discriminantValue": { + "wireValue": "message", + "name": { + "originalName": "message", + "camelCase": { + "unsafeName": "message", + "safeName": "message" + }, + "snakeCase": { + "unsafeName": "message", + "safeName": "message" + }, + "screamingSnakeCase": { + "unsafeName": "MESSAGE", + "safeName": "MESSAGE" + }, + "pascalCase": { + "unsafeName": "Message", + "safeName": "Message" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "interrupt": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamInterruptVariant", + "discriminantValue": { + "wireValue": "interrupt", + "name": { + "originalName": "interrupt", + "camelCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "snakeCase": { + "unsafeName": "interrupt", + "safeName": "interrupt" + }, + "screamingSnakeCase": { + "unsafeName": "INTERRUPT", + "safeName": "INTERRUPT" + }, + "pascalCase": { + "unsafeName": "Interrupt", + "safeName": "Interrupt" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "compact": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamCompactVariant", + "discriminantValue": { + "wireValue": "compact", + "name": { + "originalName": "compact", + "camelCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "snakeCase": { + "unsafeName": "compact", + "safeName": "compact" + }, + "screamingSnakeCase": { + "unsafeName": "COMPACT", + "safeName": "COMPACT" + }, + "pascalCase": { + "unsafeName": "Compact", + "safeName": "Compact" + } + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + } + } + }, + "type_:ValidateUnionRequestResponse": { + "type": "object", + "declaration": { + "name": { + "originalName": "ValidateUnionRequestResponse", + "camelCase": { + "unsafeName": "validateUnionRequestResponse", + "safeName": "validateUnionRequestResponse" + }, + "snakeCase": { + "unsafeName": "validate_union_request_response", + "safeName": "validate_union_request_response" + }, + "screamingSnakeCase": { + "unsafeName": "VALIDATE_UNION_REQUEST_RESPONSE", + "safeName": "VALIDATE_UNION_REQUEST_RESPONSE" + }, + "pascalCase": { + "unsafeName": "ValidateUnionRequestResponse", + "safeName": "ValidateUnionRequestResponse" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "valid", + "name": { + "originalName": "valid", + "camelCase": { + "unsafeName": "valid", + "safeName": "valid" + }, + "snakeCase": { + "unsafeName": "valid", + "safeName": "valid" + }, + "screamingSnakeCase": { + "unsafeName": "VALID", + "safeName": "VALID" + }, + "pascalCase": { + "unsafeName": "Valid", + "safeName": "Valid" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:StreamRequest": { + "type": "object", + "declaration": { + "name": { + "originalName": "StreamRequest", + "camelCase": { + "unsafeName": "streamRequest", + "safeName": "streamRequest" + }, + "snakeCase": { + "unsafeName": "stream_request", + "safeName": "stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_REQUEST", + "safeName": "STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamRequest", + "safeName": "StreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "STRING" + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:Event": { + "type": "object", + "declaration": { + "name": { + "originalName": "Event", + "camelCase": { + "unsafeName": "event", + "safeName": "event" + }, + "snakeCase": { + "unsafeName": "event", + "safeName": "event" + }, + "screamingSnakeCase": { + "unsafeName": "EVENT", + "safeName": "EVENT" + }, + "pascalCase": { + "unsafeName": "Event", + "safeName": "Event" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "data", + "name": { + "originalName": "data", + "camelCase": { + "unsafeName": "data", + "safeName": "data" + }, + "snakeCase": { + "unsafeName": "data", + "safeName": "data" + }, + "screamingSnakeCase": { + "unsafeName": "DATA", + "safeName": "DATA" + }, + "pascalCase": { + "unsafeName": "Data", + "safeName": "Data" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "event", + "name": { + "originalName": "event", + "camelCase": { + "unsafeName": "event", + "safeName": "event" + }, + "snakeCase": { + "unsafeName": "event", + "safeName": "event" + }, + "screamingSnakeCase": { + "unsafeName": "EVENT", + "safeName": "EVENT" + }, + "pascalCase": { + "unsafeName": "Event", + "safeName": "Event" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "STRING" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "id", + "name": { + "originalName": "id", + "camelCase": { + "unsafeName": "id", + "safeName": "id" + }, + "snakeCase": { + "unsafeName": "id", + "safeName": "id" + }, + "screamingSnakeCase": { + "unsafeName": "ID", + "safeName": "ID" + }, + "pascalCase": { + "unsafeName": "ID", + "safeName": "ID" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "STRING" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "retry", + "name": { + "originalName": "retry", + "camelCase": { + "unsafeName": "retry", + "safeName": "retry" + }, + "snakeCase": { + "unsafeName": "retry", + "safeName": "retry" + }, + "screamingSnakeCase": { + "unsafeName": "RETRY", + "safeName": "RETRY" + }, + "pascalCase": { + "unsafeName": "Retry", + "safeName": "Retry" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "INTEGER" + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:StatusPayload": { + "type": "object", + "declaration": { + "name": { + "originalName": "StatusPayload", + "camelCase": { + "unsafeName": "statusPayload", + "safeName": "statusPayload" + }, + "snakeCase": { + "unsafeName": "status_payload", + "safeName": "status_payload" + }, + "screamingSnakeCase": { + "unsafeName": "STATUS_PAYLOAD", + "safeName": "STATUS_PAYLOAD" + }, + "pascalCase": { + "unsafeName": "StatusPayload", + "safeName": "StatusPayload" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "message", + "name": { + "originalName": "message", + "camelCase": { + "unsafeName": "message", + "safeName": "message" + }, + "snakeCase": { + "unsafeName": "message", + "safeName": "message" + }, + "screamingSnakeCase": { + "unsafeName": "MESSAGE", + "safeName": "MESSAGE" + }, + "pascalCase": { + "unsafeName": "Message", + "safeName": "Message" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "timestamp", + "name": { + "originalName": "timestamp", + "camelCase": { + "unsafeName": "timestamp", + "safeName": "timestamp" + }, + "snakeCase": { + "unsafeName": "timestamp", + "safeName": "timestamp" + }, + "screamingSnakeCase": { + "unsafeName": "TIMESTAMP", + "safeName": "TIMESTAMP" + }, + "pascalCase": { + "unsafeName": "Timestamp", + "safeName": "Timestamp" + } } + }, + "typeReference": { + "type": "primitive", + "value": "DATE_TIME" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:ObjectPayloadWithEventField": { + "type": "object", + "declaration": { + "name": { + "originalName": "ObjectPayloadWithEventField", + "camelCase": { + "unsafeName": "objectPayloadWithEventField", + "safeName": "objectPayloadWithEventField" + }, + "snakeCase": { + "unsafeName": "object_payload_with_event_field", + "safeName": "object_payload_with_event_field" + }, + "screamingSnakeCase": { + "unsafeName": "OBJECT_PAYLOAD_WITH_EVENT_FIELD", + "safeName": "OBJECT_PAYLOAD_WITH_EVENT_FIELD" + }, + "pascalCase": { + "unsafeName": "ObjectPayloadWithEventField", + "safeName": "ObjectPayloadWithEventField" } - ], - "pagination": null, - "transport": null, - "v2Examples": null, - "source": null, - "audiences": null, - "retries": null, - "apiPlayground": null, - "responseHeaders": [], - "availability": null, - "docs": "Follows the pattern from the OAS 3.2 specification's own SSE example. The itemSchema extends a base Event schema via $ref and uses inline oneOf variants with const on the event field to distinguish event types. Data fields use contentSchema/contentMediaType for structured payloads. No discriminator object is used. Event type resolution relies on const matching." - } - ], - "audiences": null - } - }, - "constants": { - "errorInstanceIdKey": "errorInstanceId" - }, - "environments": null, - "errorDiscriminationStrategy": { - "type": "statusCode" - }, - "basePath": null, - "pathParameters": [], - "variables": [], - "serviceTypeReferenceInfo": { - "typesReferencedOnlyByService": { - "service_": [ - "type_:StreamProtocolNoCollisionResponse", - "type_:StreamProtocolCollisionResponse", - "type_:StreamDataContextResponse", - "type_:StreamNoContextResponse", - "type_:StreamProtocolWithFlatSchemaResponse", - "type_:StreamDataContextWithEnvelopeSchemaResponse", - "type_:StreamRequest", - "type_:Event", - "type_:StatusPayload", - "type_:ObjectPayloadWithEventField", - "type_:HeartbeatPayload", - "type_:EntityEventPayloadEventType", - "type_:EntityEventPayload", - "type_:ProtocolHeartbeat", - "type_:ProtocolStringEvent", - "type_:ProtocolNumberEvent", - "type_:ProtocolObjectEvent", - "type_:ProtocolCollisionObjectEvent", - "type_:DataContextHeartbeat", - "type_:DataContextEntityEvent" - ] - }, - "sharedTypes": [] - }, - "webhookGroups": {}, - "websocketChannels": {}, - "readmeConfig": null, - "sourceConfig": null, - "publishConfig": null, - "dynamic": { - "version": "1.0.0", - "types": { - "type_:StreamProtocolNoCollisionResponse": { - "type": "discriminatedUnion", + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "id", + "name": { + "originalName": "id", + "camelCase": { + "unsafeName": "id", + "safeName": "id" + }, + "snakeCase": { + "unsafeName": "id", + "safeName": "id" + }, + "screamingSnakeCase": { + "unsafeName": "ID", + "safeName": "ID" + }, + "pascalCase": { + "unsafeName": "ID", + "safeName": "ID" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "name", + "name": { + "originalName": "name", + "camelCase": { + "unsafeName": "name", + "safeName": "name" + }, + "snakeCase": { + "unsafeName": "name", + "safeName": "name" + }, + "screamingSnakeCase": { + "unsafeName": "NAME", + "safeName": "NAME" + }, + "pascalCase": { + "unsafeName": "Name", + "safeName": "Name" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "event", + "name": { + "originalName": "event", + "camelCase": { + "unsafeName": "event", + "safeName": "event" + }, + "snakeCase": { + "unsafeName": "event", + "safeName": "event" + }, + "screamingSnakeCase": { + "unsafeName": "EVENT", + "safeName": "EVENT" + }, + "pascalCase": { + "unsafeName": "Event", + "safeName": "Event" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:HeartbeatPayload": { + "type": "object", + "declaration": { + "name": { + "originalName": "HeartbeatPayload", + "camelCase": { + "unsafeName": "heartbeatPayload", + "safeName": "heartbeatPayload" + }, + "snakeCase": { + "unsafeName": "heartbeat_payload", + "safeName": "heartbeat_payload" + }, + "screamingSnakeCase": { + "unsafeName": "HEARTBEAT_PAYLOAD", + "safeName": "HEARTBEAT_PAYLOAD" + }, + "pascalCase": { + "unsafeName": "HeartbeatPayload", + "safeName": "HeartbeatPayload" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "timestamp", + "name": { + "originalName": "timestamp", + "camelCase": { + "unsafeName": "timestamp", + "safeName": "timestamp" + }, + "snakeCase": { + "unsafeName": "timestamp", + "safeName": "timestamp" + }, + "screamingSnakeCase": { + "unsafeName": "TIMESTAMP", + "safeName": "TIMESTAMP" + }, + "pascalCase": { + "unsafeName": "Timestamp", + "safeName": "Timestamp" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "DATE_TIME" + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:EntityEventPayloadEventType": { + "type": "enum", "declaration": { "name": { - "originalName": "StreamProtocolNoCollisionResponse", + "originalName": "EntityEventPayloadEventType", "camelCase": { - "unsafeName": "streamProtocolNoCollisionResponse", - "safeName": "streamProtocolNoCollisionResponse" + "unsafeName": "entityEventPayloadEventType", + "safeName": "entityEventPayloadEventType" }, "snakeCase": { - "unsafeName": "stream_protocol_no_collision_response", - "safeName": "stream_protocol_no_collision_response" + "unsafeName": "entity_event_payload_event_type", + "safeName": "entity_event_payload_event_type" }, "screamingSnakeCase": { - "unsafeName": "STREAM_PROTOCOL_NO_COLLISION_RESPONSE", - "safeName": "STREAM_PROTOCOL_NO_COLLISION_RESPONSE" + "unsafeName": "ENTITY_EVENT_PAYLOAD_EVENT_TYPE", + "safeName": "ENTITY_EVENT_PAYLOAD_EVENT_TYPE" }, "pascalCase": { - "unsafeName": "StreamProtocolNoCollisionResponse", - "safeName": "StreamProtocolNoCollisionResponse" + "unsafeName": "EntityEventPayloadEventType", + "safeName": "EntityEventPayloadEventType" } }, "fernFilepath": { @@ -4453,159 +13229,249 @@ "file": null } }, - "discriminant": { - "wireValue": "event", + "values": [ + { + "wireValue": "CREATED", + "name": { + "originalName": "CREATED", + "camelCase": { + "unsafeName": "created", + "safeName": "created" + }, + "snakeCase": { + "unsafeName": "created", + "safeName": "created" + }, + "screamingSnakeCase": { + "unsafeName": "CREATED", + "safeName": "CREATED" + }, + "pascalCase": { + "unsafeName": "Created", + "safeName": "Created" + } + } + }, + { + "wireValue": "UPDATED", + "name": { + "originalName": "UPDATED", + "camelCase": { + "unsafeName": "updated", + "safeName": "updated" + }, + "snakeCase": { + "unsafeName": "updated", + "safeName": "updated" + }, + "screamingSnakeCase": { + "unsafeName": "UPDATED", + "safeName": "UPDATED" + }, + "pascalCase": { + "unsafeName": "Updated", + "safeName": "Updated" + } + } + }, + { + "wireValue": "DELETED", + "name": { + "originalName": "DELETED", + "camelCase": { + "unsafeName": "deleted", + "safeName": "deleted" + }, + "snakeCase": { + "unsafeName": "deleted", + "safeName": "deleted" + }, + "screamingSnakeCase": { + "unsafeName": "DELETED", + "safeName": "DELETED" + }, + "pascalCase": { + "unsafeName": "Deleted", + "safeName": "Deleted" + } + } + }, + { + "wireValue": "PREEXISTING", + "name": { + "originalName": "PREEXISTING", + "camelCase": { + "unsafeName": "preexisting", + "safeName": "preexisting" + }, + "snakeCase": { + "unsafeName": "preexisting", + "safeName": "preexisting" + }, + "screamingSnakeCase": { + "unsafeName": "PREEXISTING", + "safeName": "PREEXISTING" + }, + "pascalCase": { + "unsafeName": "Preexisting", + "safeName": "Preexisting" + } + } + } + ] + }, + "type_:EntityEventPayload": { + "type": "object", + "declaration": { "name": { - "originalName": "event", + "originalName": "EntityEventPayload", "camelCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "entityEventPayload", + "safeName": "entityEventPayload" }, "snakeCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "entity_event_payload", + "safeName": "entity_event_payload" }, "screamingSnakeCase": { - "unsafeName": "EVENT", - "safeName": "EVENT" + "unsafeName": "ENTITY_EVENT_PAYLOAD", + "safeName": "ENTITY_EVENT_PAYLOAD" }, "pascalCase": { - "unsafeName": "Event", - "safeName": "Event" + "unsafeName": "EntityEventPayload", + "safeName": "EntityEventPayload" } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null } }, - "types": { - "heartbeat": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolHeartbeat", - "discriminantValue": { - "wireValue": "heartbeat", + "properties": [ + { + "name": { + "wireValue": "entityId", "name": { - "originalName": "heartbeat", + "originalName": "entityId", "camelCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "entityID", + "safeName": "entityID" }, "snakeCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "entity_id", + "safeName": "entity_id" }, "screamingSnakeCase": { - "unsafeName": "HEARTBEAT", - "safeName": "HEARTBEAT" + "unsafeName": "ENTITY_ID", + "safeName": "ENTITY_ID" }, "pascalCase": { - "unsafeName": "Heartbeat", - "safeName": "Heartbeat" + "unsafeName": "EntityID", + "safeName": "EntityID" } } }, - "properties": [] - }, - "string_data": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolStringEvent", - "discriminantValue": { - "wireValue": "string_data", - "name": { - "originalName": "string_data", - "camelCase": { - "unsafeName": "stringData", - "safeName": "stringData" - }, - "snakeCase": { - "unsafeName": "string_data", - "safeName": "string_data" - }, - "screamingSnakeCase": { - "unsafeName": "STRING_DATA", - "safeName": "STRING_DATA" - }, - "pascalCase": { - "unsafeName": "StringData", - "safeName": "StringData" - } + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "STRING" } }, - "properties": [] - }, - "number_data": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolNumberEvent", - "discriminantValue": { - "wireValue": "number_data", + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "eventType", "name": { - "originalName": "number_data", + "originalName": "eventType", "camelCase": { - "unsafeName": "numberData", - "safeName": "numberData" + "unsafeName": "eventType", + "safeName": "eventType" }, "snakeCase": { - "unsafeName": "number_data", - "safeName": "number_data" + "unsafeName": "event_type", + "safeName": "event_type" }, "screamingSnakeCase": { - "unsafeName": "NUMBER_DATA", - "safeName": "NUMBER_DATA" + "unsafeName": "EVENT_TYPE", + "safeName": "EVENT_TYPE" }, "pascalCase": { - "unsafeName": "NumberData", - "safeName": "NumberData" + "unsafeName": "EventType", + "safeName": "EventType" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "named", + "value": "type_:EntityEventPayloadEventType" + } + }, + "propertyAccess": null, + "variable": null }, - "object_data": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolObjectEvent", - "discriminantValue": { - "wireValue": "object_data", + { + "name": { + "wireValue": "updatedTime", "name": { - "originalName": "object_data", + "originalName": "updatedTime", "camelCase": { - "unsafeName": "objectData", - "safeName": "objectData" + "unsafeName": "updatedTime", + "safeName": "updatedTime" }, "snakeCase": { - "unsafeName": "object_data", - "safeName": "object_data" + "unsafeName": "updated_time", + "safeName": "updated_time" }, "screamingSnakeCase": { - "unsafeName": "OBJECT_DATA", - "safeName": "OBJECT_DATA" + "unsafeName": "UPDATED_TIME", + "safeName": "UPDATED_TIME" }, "pascalCase": { - "unsafeName": "ObjectData", - "safeName": "ObjectData" + "unsafeName": "UpdatedTime", + "safeName": "UpdatedTime" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "DATE_TIME" + } + }, + "propertyAccess": null, + "variable": null } - } + ], + "extends": null, + "additionalProperties": false }, - "type_:StreamProtocolCollisionResponse": { - "type": "discriminatedUnion", + "type_:ProtocolHeartbeat": { + "type": "object", "declaration": { "name": { - "originalName": "StreamProtocolCollisionResponse", + "originalName": "ProtocolHeartbeat", "camelCase": { - "unsafeName": "streamProtocolCollisionResponse", - "safeName": "streamProtocolCollisionResponse" + "unsafeName": "protocolHeartbeat", + "safeName": "protocolHeartbeat" }, "snakeCase": { - "unsafeName": "stream_protocol_collision_response", - "safeName": "stream_protocol_collision_response" + "unsafeName": "protocol_heartbeat", + "safeName": "protocol_heartbeat" }, "screamingSnakeCase": { - "unsafeName": "STREAM_PROTOCOL_COLLISION_RESPONSE", - "safeName": "STREAM_PROTOCOL_COLLISION_RESPONSE" + "unsafeName": "PROTOCOL_HEARTBEAT", + "safeName": "PROTOCOL_HEARTBEAT" }, "pascalCase": { - "unsafeName": "StreamProtocolCollisionResponse", - "safeName": "StreamProtocolCollisionResponse" + "unsafeName": "ProtocolHeartbeat", + "safeName": "ProtocolHeartbeat" } }, "fernFilepath": { @@ -4614,159 +13480,350 @@ "file": null } }, - "discriminant": { - "wireValue": "event", + "properties": [], + "extends": null, + "additionalProperties": false + }, + "type_:ProtocolStringEvent": { + "type": "object", + "declaration": { "name": { - "originalName": "event", + "originalName": "ProtocolStringEvent", "camelCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "protocolStringEvent", + "safeName": "protocolStringEvent" }, "snakeCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "protocol_string_event", + "safeName": "protocol_string_event" }, "screamingSnakeCase": { - "unsafeName": "EVENT", - "safeName": "EVENT" + "unsafeName": "PROTOCOL_STRING_EVENT", + "safeName": "PROTOCOL_STRING_EVENT" }, "pascalCase": { - "unsafeName": "Event", - "safeName": "Event" + "unsafeName": "ProtocolStringEvent", + "safeName": "ProtocolStringEvent" } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null } }, - "types": { - "heartbeat": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolHeartbeat", - "discriminantValue": { - "wireValue": "heartbeat", + "properties": [ + { + "name": { + "wireValue": "data", "name": { - "originalName": "heartbeat", + "originalName": "data", "camelCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "data", + "safeName": "data" }, "snakeCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "data", + "safeName": "data" }, "screamingSnakeCase": { - "unsafeName": "HEARTBEAT", - "safeName": "HEARTBEAT" + "unsafeName": "DATA", + "safeName": "DATA" }, "pascalCase": { - "unsafeName": "Heartbeat", - "safeName": "Heartbeat" + "unsafeName": "Data", + "safeName": "Data" } } }, - "properties": [] + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:ProtocolNumberEvent": { + "type": "object", + "declaration": { + "name": { + "originalName": "ProtocolNumberEvent", + "camelCase": { + "unsafeName": "protocolNumberEvent", + "safeName": "protocolNumberEvent" + }, + "snakeCase": { + "unsafeName": "protocol_number_event", + "safeName": "protocol_number_event" + }, + "screamingSnakeCase": { + "unsafeName": "PROTOCOL_NUMBER_EVENT", + "safeName": "PROTOCOL_NUMBER_EVENT" + }, + "pascalCase": { + "unsafeName": "ProtocolNumberEvent", + "safeName": "ProtocolNumberEvent" + } }, - "string_data": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolStringEvent", - "discriminantValue": { - "wireValue": "string_data", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "data", + "name": { + "originalName": "data", + "camelCase": { + "unsafeName": "data", + "safeName": "data" + }, + "snakeCase": { + "unsafeName": "data", + "safeName": "data" + }, + "screamingSnakeCase": { + "unsafeName": "DATA", + "safeName": "DATA" + }, + "pascalCase": { + "unsafeName": "Data", + "safeName": "Data" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "DOUBLE" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:ProtocolObjectEvent": { + "type": "object", + "declaration": { + "name": { + "originalName": "ProtocolObjectEvent", + "camelCase": { + "unsafeName": "protocolObjectEvent", + "safeName": "protocolObjectEvent" + }, + "snakeCase": { + "unsafeName": "protocol_object_event", + "safeName": "protocol_object_event" + }, + "screamingSnakeCase": { + "unsafeName": "PROTOCOL_OBJECT_EVENT", + "safeName": "PROTOCOL_OBJECT_EVENT" + }, + "pascalCase": { + "unsafeName": "ProtocolObjectEvent", + "safeName": "ProtocolObjectEvent" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "data", "name": { - "originalName": "string_data", + "originalName": "data", "camelCase": { - "unsafeName": "stringData", - "safeName": "stringData" + "unsafeName": "data", + "safeName": "data" }, "snakeCase": { - "unsafeName": "string_data", - "safeName": "string_data" + "unsafeName": "data", + "safeName": "data" }, "screamingSnakeCase": { - "unsafeName": "STRING_DATA", - "safeName": "STRING_DATA" + "unsafeName": "DATA", + "safeName": "DATA" }, "pascalCase": { - "unsafeName": "StringData", - "safeName": "StringData" + "unsafeName": "Data", + "safeName": "Data" } } }, - "properties": [] + "typeReference": { + "type": "named", + "value": "type_:StatusPayload" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:ProtocolCollisionObjectEvent": { + "type": "object", + "declaration": { + "name": { + "originalName": "ProtocolCollisionObjectEvent", + "camelCase": { + "unsafeName": "protocolCollisionObjectEvent", + "safeName": "protocolCollisionObjectEvent" + }, + "snakeCase": { + "unsafeName": "protocol_collision_object_event", + "safeName": "protocol_collision_object_event" + }, + "screamingSnakeCase": { + "unsafeName": "PROTOCOL_COLLISION_OBJECT_EVENT", + "safeName": "PROTOCOL_COLLISION_OBJECT_EVENT" + }, + "pascalCase": { + "unsafeName": "ProtocolCollisionObjectEvent", + "safeName": "ProtocolCollisionObjectEvent" + } }, - "number_data": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolNumberEvent", - "discriminantValue": { - "wireValue": "number_data", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "data", "name": { - "originalName": "number_data", + "originalName": "data", "camelCase": { - "unsafeName": "numberData", - "safeName": "numberData" + "unsafeName": "data", + "safeName": "data" }, "snakeCase": { - "unsafeName": "number_data", - "safeName": "number_data" + "unsafeName": "data", + "safeName": "data" }, "screamingSnakeCase": { - "unsafeName": "NUMBER_DATA", - "safeName": "NUMBER_DATA" + "unsafeName": "DATA", + "safeName": "DATA" }, "pascalCase": { - "unsafeName": "NumberData", - "safeName": "NumberData" + "unsafeName": "Data", + "safeName": "Data" } } }, - "properties": [] + "typeReference": { + "type": "named", + "value": "type_:ObjectPayloadWithEventField" + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:DataContextHeartbeat": { + "type": "object", + "declaration": { + "name": { + "originalName": "DataContextHeartbeat", + "camelCase": { + "unsafeName": "dataContextHeartbeat", + "safeName": "dataContextHeartbeat" + }, + "snakeCase": { + "unsafeName": "data_context_heartbeat", + "safeName": "data_context_heartbeat" + }, + "screamingSnakeCase": { + "unsafeName": "DATA_CONTEXT_HEARTBEAT", + "safeName": "DATA_CONTEXT_HEARTBEAT" + }, + "pascalCase": { + "unsafeName": "DataContextHeartbeat", + "safeName": "DataContextHeartbeat" + } }, - "object_data": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolCollisionObjectEvent", - "discriminantValue": { - "wireValue": "object_data", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "timestamp", "name": { - "originalName": "object_data", + "originalName": "timestamp", "camelCase": { - "unsafeName": "objectData", - "safeName": "objectData" + "unsafeName": "timestamp", + "safeName": "timestamp" }, "snakeCase": { - "unsafeName": "object_data", - "safeName": "object_data" + "unsafeName": "timestamp", + "safeName": "timestamp" }, "screamingSnakeCase": { - "unsafeName": "OBJECT_DATA", - "safeName": "OBJECT_DATA" + "unsafeName": "TIMESTAMP", + "safeName": "TIMESTAMP" }, "pascalCase": { - "unsafeName": "ObjectData", - "safeName": "ObjectData" + "unsafeName": "Timestamp", + "safeName": "Timestamp" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "DATE_TIME" + } + }, + "propertyAccess": null, + "variable": null } - } + ], + "extends": [ + "type_:HeartbeatPayload" + ], + "additionalProperties": false }, - "type_:StreamDataContextResponse": { - "type": "discriminatedUnion", + "type_:DataContextEntityEvent": { + "type": "object", "declaration": { "name": { - "originalName": "StreamDataContextResponse", + "originalName": "DataContextEntityEvent", "camelCase": { - "unsafeName": "streamDataContextResponse", - "safeName": "streamDataContextResponse" + "unsafeName": "dataContextEntityEvent", + "safeName": "dataContextEntityEvent" }, "snakeCase": { - "unsafeName": "stream_data_context_response", - "safeName": "stream_data_context_response" + "unsafeName": "data_context_entity_event", + "safeName": "data_context_entity_event" }, "screamingSnakeCase": { - "unsafeName": "STREAM_DATA_CONTEXT_RESPONSE", - "safeName": "STREAM_DATA_CONTEXT_RESPONSE" + "unsafeName": "DATA_CONTEXT_ENTITY_EVENT", + "safeName": "DATA_CONTEXT_ENTITY_EVENT" }, "pascalCase": { - "unsafeName": "StreamDataContextResponse", - "safeName": "StreamDataContextResponse" + "unsafeName": "DataContextEntityEvent", + "safeName": "DataContextEntityEvent" } }, "fernFilepath": { @@ -4775,105 +13832,132 @@ "file": null } }, - "discriminant": { - "wireValue": "event", - "name": { - "originalName": "event", - "camelCase": { - "unsafeName": "event", - "safeName": "event" - }, - "snakeCase": { - "unsafeName": "event", - "safeName": "event" + "properties": [ + { + "name": { + "wireValue": "entityId", + "name": { + "originalName": "entityId", + "camelCase": { + "unsafeName": "entityID", + "safeName": "entityID" + }, + "snakeCase": { + "unsafeName": "entity_id", + "safeName": "entity_id" + }, + "screamingSnakeCase": { + "unsafeName": "ENTITY_ID", + "safeName": "ENTITY_ID" + }, + "pascalCase": { + "unsafeName": "EntityID", + "safeName": "EntityID" + } + } }, - "screamingSnakeCase": { - "unsafeName": "EVENT", - "safeName": "EVENT" + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "STRING" + } }, - "pascalCase": { - "unsafeName": "Event", - "safeName": "Event" - } - } - }, - "types": { - "heartbeat": { - "type": "samePropertiesAsObject", - "typeId": "type_:DataContextHeartbeat", - "discriminantValue": { - "wireValue": "heartbeat", + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "eventType", "name": { - "originalName": "heartbeat", + "originalName": "eventType", "camelCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "eventType", + "safeName": "eventType" }, "snakeCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "event_type", + "safeName": "event_type" }, "screamingSnakeCase": { - "unsafeName": "HEARTBEAT", - "safeName": "HEARTBEAT" + "unsafeName": "EVENT_TYPE", + "safeName": "EVENT_TYPE" }, "pascalCase": { - "unsafeName": "Heartbeat", - "safeName": "Heartbeat" + "unsafeName": "EventType", + "safeName": "EventType" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "named", + "value": "type_:EntityEventPayloadEventType" + } + }, + "propertyAccess": null, + "variable": null }, - "entity": { - "type": "samePropertiesAsObject", - "typeId": "type_:DataContextEntityEvent", - "discriminantValue": { - "wireValue": "entity", + { + "name": { + "wireValue": "updatedTime", "name": { - "originalName": "entity", + "originalName": "updatedTime", "camelCase": { - "unsafeName": "entity", - "safeName": "entity" + "unsafeName": "updatedTime", + "safeName": "updatedTime" }, "snakeCase": { - "unsafeName": "entity", - "safeName": "entity" + "unsafeName": "updated_time", + "safeName": "updated_time" }, "screamingSnakeCase": { - "unsafeName": "ENTITY", - "safeName": "ENTITY" + "unsafeName": "UPDATED_TIME", + "safeName": "UPDATED_TIME" }, "pascalCase": { - "unsafeName": "Entity", - "safeName": "Entity" + "unsafeName": "UpdatedTime", + "safeName": "UpdatedTime" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "DATE_TIME" + } + }, + "propertyAccess": null, + "variable": null } - } + ], + "extends": [ + "type_:EntityEventPayload" + ], + "additionalProperties": false }, - "type_:StreamNoContextResponse": { - "type": "discriminatedUnion", + "type_:CompletionRequest": { + "type": "object", "declaration": { "name": { - "originalName": "StreamNoContextResponse", + "originalName": "CompletionRequest", "camelCase": { - "unsafeName": "streamNoContextResponse", - "safeName": "streamNoContextResponse" + "unsafeName": "completionRequest", + "safeName": "completionRequest" }, "snakeCase": { - "unsafeName": "stream_no_context_response", - "safeName": "stream_no_context_response" + "unsafeName": "completion_request", + "safeName": "completion_request" }, "screamingSnakeCase": { - "unsafeName": "STREAM_NO_CONTEXT_RESPONSE", - "safeName": "STREAM_NO_CONTEXT_RESPONSE" + "unsafeName": "COMPLETION_REQUEST", + "safeName": "COMPLETION_REQUEST" }, "pascalCase": { - "unsafeName": "StreamNoContextResponse", - "safeName": "StreamNoContextResponse" + "unsafeName": "CompletionRequest", + "safeName": "CompletionRequest" } }, "fernFilepath": { @@ -4882,105 +13966,94 @@ "file": null } }, - "discriminant": { - "wireValue": "event", - "name": { - "originalName": "event", - "camelCase": { - "unsafeName": "event", - "safeName": "event" - }, - "snakeCase": { - "unsafeName": "event", - "safeName": "event" - }, - "screamingSnakeCase": { - "unsafeName": "EVENT", - "safeName": "EVENT" - }, - "pascalCase": { - "unsafeName": "Event", - "safeName": "Event" - } - } - }, - "types": { - "heartbeat": { - "type": "samePropertiesAsObject", - "typeId": "type_:DataContextHeartbeat", - "discriminantValue": { - "wireValue": "heartbeat", + "properties": [ + { + "name": { + "wireValue": "query", "name": { - "originalName": "heartbeat", + "originalName": "query", "camelCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "query", + "safeName": "query" }, "snakeCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "query", + "safeName": "query" }, "screamingSnakeCase": { - "unsafeName": "HEARTBEAT", - "safeName": "HEARTBEAT" + "unsafeName": "QUERY", + "safeName": "QUERY" }, "pascalCase": { - "unsafeName": "Heartbeat", - "safeName": "Heartbeat" + "unsafeName": "Query", + "safeName": "Query" } } }, - "properties": [] + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null }, - "entity": { - "type": "samePropertiesAsObject", - "typeId": "type_:DataContextEntityEvent", - "discriminantValue": { - "wireValue": "entity", + { + "name": { + "wireValue": "stream", "name": { - "originalName": "entity", + "originalName": "stream", "camelCase": { - "unsafeName": "entity", - "safeName": "entity" + "unsafeName": "stream", + "safeName": "stream" }, "snakeCase": { - "unsafeName": "entity", - "safeName": "entity" + "unsafeName": "stream", + "safeName": "stream" }, "screamingSnakeCase": { - "unsafeName": "ENTITY", - "safeName": "ENTITY" + "unsafeName": "STREAM", + "safeName": "STREAM" }, "pascalCase": { - "unsafeName": "Entity", - "safeName": "Entity" + "unsafeName": "Stream", + "safeName": "Stream" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null } - } + ], + "extends": null, + "additionalProperties": false }, - "type_:StreamProtocolWithFlatSchemaResponse": { - "type": "discriminatedUnion", + "type_:NullableStreamRequest": { + "type": "object", "declaration": { "name": { - "originalName": "StreamProtocolWithFlatSchemaResponse", + "originalName": "NullableStreamRequest", "camelCase": { - "unsafeName": "streamProtocolWithFlatSchemaResponse", - "safeName": "streamProtocolWithFlatSchemaResponse" + "unsafeName": "nullableStreamRequest", + "safeName": "nullableStreamRequest" }, "snakeCase": { - "unsafeName": "stream_protocol_with_flat_schema_response", - "safeName": "stream_protocol_with_flat_schema_response" + "unsafeName": "nullable_stream_request", + "safeName": "nullable_stream_request" }, "screamingSnakeCase": { - "unsafeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA_RESPONSE", - "safeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA_RESPONSE" + "unsafeName": "NULLABLE_STREAM_REQUEST", + "safeName": "NULLABLE_STREAM_REQUEST" }, "pascalCase": { - "unsafeName": "StreamProtocolWithFlatSchemaResponse", - "safeName": "StreamProtocolWithFlatSchemaResponse" + "unsafeName": "NullableStreamRequest", + "safeName": "NullableStreamRequest" } }, "fernFilepath": { @@ -4989,105 +14062,97 @@ "file": null } }, - "discriminant": { - "wireValue": "event", - "name": { - "originalName": "event", - "camelCase": { - "unsafeName": "event", - "safeName": "event" - }, - "snakeCase": { - "unsafeName": "event", - "safeName": "event" - }, - "screamingSnakeCase": { - "unsafeName": "EVENT", - "safeName": "EVENT" - }, - "pascalCase": { - "unsafeName": "Event", - "safeName": "Event" - } - } - }, - "types": { - "heartbeat": { - "type": "samePropertiesAsObject", - "typeId": "type_:DataContextHeartbeat", - "discriminantValue": { - "wireValue": "heartbeat", + "properties": [ + { + "name": { + "wireValue": "query", "name": { - "originalName": "heartbeat", + "originalName": "query", "camelCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "query", + "safeName": "query" }, "snakeCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "query", + "safeName": "query" }, "screamingSnakeCase": { - "unsafeName": "HEARTBEAT", - "safeName": "HEARTBEAT" + "unsafeName": "QUERY", + "safeName": "QUERY" }, "pascalCase": { - "unsafeName": "Heartbeat", - "safeName": "Heartbeat" + "unsafeName": "Query", + "safeName": "Query" } } }, - "properties": [] + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null }, - "entity": { - "type": "samePropertiesAsObject", - "typeId": "type_:DataContextEntityEvent", - "discriminantValue": { - "wireValue": "entity", + { + "name": { + "wireValue": "stream", "name": { - "originalName": "entity", + "originalName": "stream", "camelCase": { - "unsafeName": "entity", - "safeName": "entity" + "unsafeName": "stream", + "safeName": "stream" }, "snakeCase": { - "unsafeName": "entity", - "safeName": "entity" + "unsafeName": "stream", + "safeName": "stream" }, - "screamingSnakeCase": { - "unsafeName": "ENTITY", - "safeName": "ENTITY" + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" }, "pascalCase": { - "unsafeName": "Entity", - "safeName": "Entity" + "unsafeName": "Stream", + "safeName": "Stream" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "nullable", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + } + }, + "propertyAccess": null, + "variable": null } - } + ], + "extends": null, + "additionalProperties": false }, - "type_:StreamDataContextWithEnvelopeSchemaResponse": { - "type": "discriminatedUnion", + "type_:CompletionFullResponseFinishReason": { + "type": "enum", "declaration": { "name": { - "originalName": "StreamDataContextWithEnvelopeSchemaResponse", + "originalName": "CompletionFullResponseFinishReason", "camelCase": { - "unsafeName": "streamDataContextWithEnvelopeSchemaResponse", - "safeName": "streamDataContextWithEnvelopeSchemaResponse" + "unsafeName": "completionFullResponseFinishReason", + "safeName": "completionFullResponseFinishReason" }, "snakeCase": { - "unsafeName": "stream_data_context_with_envelope_schema_response", - "safeName": "stream_data_context_with_envelope_schema_response" + "unsafeName": "completion_full_response_finish_reason", + "safeName": "completion_full_response_finish_reason" }, "screamingSnakeCase": { - "unsafeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA_RESPONSE", - "safeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA_RESPONSE" + "unsafeName": "COMPLETION_FULL_RESPONSE_FINISH_REASON", + "safeName": "COMPLETION_FULL_RESPONSE_FINISH_REASON" }, "pascalCase": { - "unsafeName": "StreamDataContextWithEnvelopeSchemaResponse", - "safeName": "StreamDataContextWithEnvelopeSchemaResponse" + "unsafeName": "CompletionFullResponseFinishReason", + "safeName": "CompletionFullResponseFinishReason" } }, "fernFilepath": { @@ -5096,197 +14161,361 @@ "file": null } }, - "discriminant": { - "wireValue": "event", + "values": [ + { + "wireValue": "complete", + "name": { + "originalName": "complete", + "camelCase": { + "unsafeName": "complete", + "safeName": "complete" + }, + "snakeCase": { + "unsafeName": "complete", + "safeName": "complete" + }, + "screamingSnakeCase": { + "unsafeName": "COMPLETE", + "safeName": "COMPLETE" + }, + "pascalCase": { + "unsafeName": "Complete", + "safeName": "Complete" + } + } + }, + { + "wireValue": "length", + "name": { + "originalName": "length", + "camelCase": { + "unsafeName": "length", + "safeName": "length" + }, + "snakeCase": { + "unsafeName": "length", + "safeName": "length" + }, + "screamingSnakeCase": { + "unsafeName": "LENGTH", + "safeName": "LENGTH" + }, + "pascalCase": { + "unsafeName": "Length", + "safeName": "Length" + } + } + }, + { + "wireValue": "error", + "name": { + "originalName": "error", + "camelCase": { + "unsafeName": "error", + "safeName": "error" + }, + "snakeCase": { + "unsafeName": "error", + "safeName": "error" + }, + "screamingSnakeCase": { + "unsafeName": "ERROR", + "safeName": "ERROR" + }, + "pascalCase": { + "unsafeName": "Error", + "safeName": "Error" + } + } + } + ] + }, + "type_:CompletionFullResponse": { + "type": "object", + "declaration": { "name": { - "originalName": "event", + "originalName": "CompletionFullResponse", "camelCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "completionFullResponse", + "safeName": "completionFullResponse" }, "snakeCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "completion_full_response", + "safeName": "completion_full_response" }, "screamingSnakeCase": { - "unsafeName": "EVENT", - "safeName": "EVENT" + "unsafeName": "COMPLETION_FULL_RESPONSE", + "safeName": "COMPLETION_FULL_RESPONSE" }, "pascalCase": { - "unsafeName": "Event", - "safeName": "Event" + "unsafeName": "CompletionFullResponse", + "safeName": "CompletionFullResponse" } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null } }, - "types": { - "heartbeat": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolHeartbeat", - "discriminantValue": { - "wireValue": "heartbeat", + "properties": [ + { + "name": { + "wireValue": "answer", "name": { - "originalName": "heartbeat", + "originalName": "answer", "camelCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "answer", + "safeName": "answer" }, "snakeCase": { - "unsafeName": "heartbeat", - "safeName": "heartbeat" + "unsafeName": "answer", + "safeName": "answer" }, "screamingSnakeCase": { - "unsafeName": "HEARTBEAT", - "safeName": "HEARTBEAT" + "unsafeName": "ANSWER", + "safeName": "ANSWER" }, "pascalCase": { - "unsafeName": "Heartbeat", - "safeName": "Heartbeat" + "unsafeName": "Answer", + "safeName": "Answer" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "STRING" + } + }, + "propertyAccess": null, + "variable": null }, - "string_data": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolStringEvent", - "discriminantValue": { - "wireValue": "string_data", + { + "name": { + "wireValue": "finishReason", "name": { - "originalName": "string_data", + "originalName": "finishReason", "camelCase": { - "unsafeName": "stringData", - "safeName": "stringData" + "unsafeName": "finishReason", + "safeName": "finishReason" }, "snakeCase": { - "unsafeName": "string_data", - "safeName": "string_data" + "unsafeName": "finish_reason", + "safeName": "finish_reason" }, "screamingSnakeCase": { - "unsafeName": "STRING_DATA", - "safeName": "STRING_DATA" + "unsafeName": "FINISH_REASON", + "safeName": "FINISH_REASON" }, "pascalCase": { - "unsafeName": "StringData", - "safeName": "StringData" + "unsafeName": "FinishReason", + "safeName": "FinishReason" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "named", + "value": "type_:CompletionFullResponseFinishReason" + } + }, + "propertyAccess": null, + "variable": null + } + ], + "extends": null, + "additionalProperties": false + }, + "type_:CompletionStreamChunk": { + "type": "object", + "declaration": { + "name": { + "originalName": "CompletionStreamChunk", + "camelCase": { + "unsafeName": "completionStreamChunk", + "safeName": "completionStreamChunk" + }, + "snakeCase": { + "unsafeName": "completion_stream_chunk", + "safeName": "completion_stream_chunk" + }, + "screamingSnakeCase": { + "unsafeName": "COMPLETION_STREAM_CHUNK", + "safeName": "COMPLETION_STREAM_CHUNK" + }, + "pascalCase": { + "unsafeName": "CompletionStreamChunk", + "safeName": "CompletionStreamChunk" + } }, - "number_data": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolNumberEvent", - "discriminantValue": { - "wireValue": "number_data", + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "delta", "name": { - "originalName": "number_data", + "originalName": "delta", "camelCase": { - "unsafeName": "numberData", - "safeName": "numberData" + "unsafeName": "delta", + "safeName": "delta" }, "snakeCase": { - "unsafeName": "number_data", - "safeName": "number_data" + "unsafeName": "delta", + "safeName": "delta" }, "screamingSnakeCase": { - "unsafeName": "NUMBER_DATA", - "safeName": "NUMBER_DATA" + "unsafeName": "DELTA", + "safeName": "DELTA" }, "pascalCase": { - "unsafeName": "NumberData", - "safeName": "NumberData" + "unsafeName": "Delta", + "safeName": "Delta" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "STRING" + } + }, + "propertyAccess": null, + "variable": null }, - "object_data": { - "type": "samePropertiesAsObject", - "typeId": "type_:ProtocolObjectEvent", - "discriminantValue": { - "wireValue": "object_data", + { + "name": { + "wireValue": "tokens", "name": { - "originalName": "object_data", + "originalName": "tokens", "camelCase": { - "unsafeName": "objectData", - "safeName": "objectData" + "unsafeName": "tokens", + "safeName": "tokens" }, "snakeCase": { - "unsafeName": "object_data", - "safeName": "object_data" + "unsafeName": "tokens", + "safeName": "tokens" }, "screamingSnakeCase": { - "unsafeName": "OBJECT_DATA", - "safeName": "OBJECT_DATA" + "unsafeName": "TOKENS", + "safeName": "TOKENS" }, "pascalCase": { - "unsafeName": "ObjectData", - "safeName": "ObjectData" + "unsafeName": "Tokens", + "safeName": "Tokens" } } }, - "properties": [] + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "INTEGER" + } + }, + "propertyAccess": null, + "variable": null } - } + ], + "extends": null, + "additionalProperties": false }, - "type_:StreamRequest": { + "type_:UnionStreamRequestBase": { "type": "object", "declaration": { "name": { - "originalName": "StreamRequest", + "originalName": "UnionStreamRequestBase", "camelCase": { - "unsafeName": "streamRequest", - "safeName": "streamRequest" + "unsafeName": "unionStreamRequestBase", + "safeName": "unionStreamRequestBase" }, "snakeCase": { - "unsafeName": "stream_request", - "safeName": "stream_request" + "unsafeName": "union_stream_request_base", + "safeName": "union_stream_request_base" }, "screamingSnakeCase": { - "unsafeName": "STREAM_REQUEST", - "safeName": "STREAM_REQUEST" + "unsafeName": "UNION_STREAM_REQUEST_BASE", + "safeName": "UNION_STREAM_REQUEST_BASE" }, "pascalCase": { - "unsafeName": "StreamRequest", - "safeName": "StreamRequest" + "unsafeName": "UnionStreamRequestBase", + "safeName": "UnionStreamRequestBase" } }, - "fernFilepath": { - "allParts": [], - "packagePath": [], - "file": null - } - }, - "properties": [ + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ + { + "name": { + "wireValue": "stream_response", + "name": { + "originalName": "stream_response", + "camelCase": { + "unsafeName": "streamResponse", + "safeName": "streamResponse" + }, + "snakeCase": { + "unsafeName": "stream_response", + "safeName": "stream_response" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" + }, + "pascalCase": { + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + }, { "name": { - "wireValue": "query", + "wireValue": "prompt", "name": { - "originalName": "query", + "originalName": "prompt", "camelCase": { - "unsafeName": "query", - "safeName": "query" + "unsafeName": "prompt", + "safeName": "prompt" }, "snakeCase": { - "unsafeName": "query", - "safeName": "query" + "unsafeName": "prompt", + "safeName": "prompt" }, "screamingSnakeCase": { - "unsafeName": "QUERY", - "safeName": "QUERY" + "unsafeName": "PROMPT", + "safeName": "PROMPT" }, "pascalCase": { - "unsafeName": "Query", - "safeName": "Query" + "unsafeName": "Prompt", + "safeName": "Prompt" } } }, "typeReference": { - "type": "optional", - "value": { - "type": "primitive", - "value": "STRING" - } + "type": "primitive", + "value": "STRING" }, "propertyAccess": null, "variable": null @@ -5295,26 +14524,26 @@ "extends": null, "additionalProperties": false }, - "type_:Event": { + "type_:UnionStreamMessageVariant": { "type": "object", "declaration": { "name": { - "originalName": "Event", + "originalName": "UnionStreamMessageVariant", "camelCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "unionStreamMessageVariant", + "safeName": "unionStreamMessageVariant" }, "snakeCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "union_stream_message_variant", + "safeName": "union_stream_message_variant" }, "screamingSnakeCase": { - "unsafeName": "EVENT", - "safeName": "EVENT" + "unsafeName": "UNION_STREAM_MESSAGE_VARIANT", + "safeName": "UNION_STREAM_MESSAGE_VARIANT" }, "pascalCase": { - "unsafeName": "Event", - "safeName": "Event" + "unsafeName": "UnionStreamMessageVariant", + "safeName": "UnionStreamMessageVariant" } }, "fernFilepath": { @@ -5326,24 +14555,57 @@ "properties": [ { "name": { - "wireValue": "data", + "wireValue": "stream_response", "name": { - "originalName": "data", + "originalName": "stream_response", "camelCase": { - "unsafeName": "data", - "safeName": "data" + "unsafeName": "streamResponse", + "safeName": "streamResponse" }, "snakeCase": { - "unsafeName": "data", - "safeName": "data" + "unsafeName": "stream_response", + "safeName": "stream_response" }, "screamingSnakeCase": { - "unsafeName": "DATA", - "safeName": "DATA" + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" }, "pascalCase": { - "unsafeName": "Data", - "safeName": "Data" + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" } } }, @@ -5356,57 +14618,89 @@ }, { "name": { - "wireValue": "event", + "wireValue": "message", "name": { - "originalName": "event", + "originalName": "message", "camelCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "message", + "safeName": "message" }, "snakeCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "message", + "safeName": "message" }, "screamingSnakeCase": { - "unsafeName": "EVENT", - "safeName": "EVENT" + "unsafeName": "MESSAGE", + "safeName": "MESSAGE" }, "pascalCase": { - "unsafeName": "Event", - "safeName": "Event" + "unsafeName": "Message", + "safeName": "Message" } } }, "typeReference": { - "type": "optional", - "value": { - "type": "primitive", - "value": "STRING" - } + "type": "primitive", + "value": "STRING" }, "propertyAccess": null, "variable": null + } + ], + "extends": [ + "type_:UnionStreamRequestBase" + ], + "additionalProperties": false + }, + "type_:UnionStreamInterruptVariant": { + "type": "object", + "declaration": { + "name": { + "originalName": "UnionStreamInterruptVariant", + "camelCase": { + "unsafeName": "unionStreamInterruptVariant", + "safeName": "unionStreamInterruptVariant" + }, + "snakeCase": { + "unsafeName": "union_stream_interrupt_variant", + "safeName": "union_stream_interrupt_variant" + }, + "screamingSnakeCase": { + "unsafeName": "UNION_STREAM_INTERRUPT_VARIANT", + "safeName": "UNION_STREAM_INTERRUPT_VARIANT" + }, + "pascalCase": { + "unsafeName": "UnionStreamInterruptVariant", + "safeName": "UnionStreamInterruptVariant" + } }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "properties": [ { "name": { - "wireValue": "id", + "wireValue": "stream_response", "name": { - "originalName": "id", + "originalName": "stream_response", "camelCase": { - "unsafeName": "id", - "safeName": "id" + "unsafeName": "streamResponse", + "safeName": "streamResponse" }, "snakeCase": { - "unsafeName": "id", - "safeName": "id" + "unsafeName": "stream_response", + "safeName": "stream_response" }, "screamingSnakeCase": { - "unsafeName": "ID", - "safeName": "ID" + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" }, "pascalCase": { - "unsafeName": "ID", - "safeName": "ID" + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" } } }, @@ -5414,7 +14708,7 @@ "type": "optional", "value": { "type": "primitive", - "value": "STRING" + "value": "BOOLEAN" } }, "propertyAccess": null, @@ -5422,61 +14716,60 @@ }, { "name": { - "wireValue": "retry", + "wireValue": "prompt", "name": { - "originalName": "retry", + "originalName": "prompt", "camelCase": { - "unsafeName": "retry", - "safeName": "retry" + "unsafeName": "prompt", + "safeName": "prompt" }, "snakeCase": { - "unsafeName": "retry", - "safeName": "retry" + "unsafeName": "prompt", + "safeName": "prompt" }, "screamingSnakeCase": { - "unsafeName": "RETRY", - "safeName": "RETRY" + "unsafeName": "PROMPT", + "safeName": "PROMPT" }, "pascalCase": { - "unsafeName": "Retry", - "safeName": "Retry" + "unsafeName": "Prompt", + "safeName": "Prompt" } } }, "typeReference": { - "type": "optional", - "value": { - "type": "primitive", - "value": "INTEGER" - } + "type": "primitive", + "value": "STRING" }, "propertyAccess": null, "variable": null } ], - "extends": null, + "extends": [ + "type_:UnionStreamRequestBase" + ], "additionalProperties": false }, - "type_:StatusPayload": { + "type_:UnionStreamCompactVariant": { "type": "object", "declaration": { "name": { - "originalName": "StatusPayload", + "originalName": "UnionStreamCompactVariant", "camelCase": { - "unsafeName": "statusPayload", - "safeName": "statusPayload" + "unsafeName": "unionStreamCompactVariant", + "safeName": "unionStreamCompactVariant" }, "snakeCase": { - "unsafeName": "status_payload", - "safeName": "status_payload" + "unsafeName": "union_stream_compact_variant", + "safeName": "union_stream_compact_variant" }, "screamingSnakeCase": { - "unsafeName": "STATUS_PAYLOAD", - "safeName": "STATUS_PAYLOAD" + "unsafeName": "UNION_STREAM_COMPACT_VARIANT", + "safeName": "UNION_STREAM_COMPACT_VARIANT" }, "pascalCase": { - "unsafeName": "StatusPayload", - "safeName": "StatusPayload" + "unsafeName": "UnionStreamCompactVariant", + "safeName": "UnionStreamCompactVariant" } }, "fernFilepath": { @@ -5488,24 +14781,57 @@ "properties": [ { "name": { - "wireValue": "message", + "wireValue": "stream_response", "name": { - "originalName": "message", + "originalName": "stream_response", "camelCase": { - "unsafeName": "message", - "safeName": "message" + "unsafeName": "streamResponse", + "safeName": "streamResponse" }, "snakeCase": { - "unsafeName": "message", - "safeName": "message" + "unsafeName": "stream_response", + "safeName": "stream_response" }, "screamingSnakeCase": { - "unsafeName": "MESSAGE", - "safeName": "MESSAGE" + "unsafeName": "STREAM_RESPONSE", + "safeName": "STREAM_RESPONSE" }, "pascalCase": { - "unsafeName": "Message", - "safeName": "Message" + "unsafeName": "StreamResponse", + "safeName": "StreamResponse" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" } } }, @@ -5518,58 +14844,60 @@ }, { "name": { - "wireValue": "timestamp", + "wireValue": "data", "name": { - "originalName": "timestamp", + "originalName": "data", "camelCase": { - "unsafeName": "timestamp", - "safeName": "timestamp" + "unsafeName": "data", + "safeName": "data" }, "snakeCase": { - "unsafeName": "timestamp", - "safeName": "timestamp" + "unsafeName": "data", + "safeName": "data" }, "screamingSnakeCase": { - "unsafeName": "TIMESTAMP", - "safeName": "TIMESTAMP" + "unsafeName": "DATA", + "safeName": "DATA" }, "pascalCase": { - "unsafeName": "Timestamp", - "safeName": "Timestamp" + "unsafeName": "Data", + "safeName": "Data" } } }, "typeReference": { "type": "primitive", - "value": "DATE_TIME" + "value": "STRING" }, "propertyAccess": null, "variable": null } ], - "extends": null, + "extends": [ + "type_:UnionStreamRequestBase" + ], "additionalProperties": false }, - "type_:ObjectPayloadWithEventField": { - "type": "object", + "type_:UnionStreamRequest": { + "type": "discriminatedUnion", "declaration": { "name": { - "originalName": "ObjectPayloadWithEventField", + "originalName": "UnionStreamRequest", "camelCase": { - "unsafeName": "objectPayloadWithEventField", - "safeName": "objectPayloadWithEventField" + "unsafeName": "unionStreamRequest", + "safeName": "unionStreamRequest" }, "snakeCase": { - "unsafeName": "object_payload_with_event_field", - "safeName": "object_payload_with_event_field" + "unsafeName": "union_stream_request", + "safeName": "union_stream_request" }, "screamingSnakeCase": { - "unsafeName": "OBJECT_PAYLOAD_WITH_EVENT_FIELD", - "safeName": "OBJECT_PAYLOAD_WITH_EVENT_FIELD" + "unsafeName": "UNION_STREAM_REQUEST", + "safeName": "UNION_STREAM_REQUEST" }, "pascalCase": { - "unsafeName": "ObjectPayloadWithEventField", - "safeName": "ObjectPayloadWithEventField" + "unsafeName": "UnionStreamRequest", + "safeName": "UnionStreamRequest" } }, "fernFilepath": { @@ -5578,121 +14906,135 @@ "file": null } }, - "properties": [ - { - "name": { - "wireValue": "id", + "discriminant": { + "wireValue": "type", + "name": { + "originalName": "type", + "camelCase": { + "unsafeName": "type", + "safeName": "type" + }, + "snakeCase": { + "unsafeName": "type", + "safeName": "type" + }, + "screamingSnakeCase": { + "unsafeName": "TYPE", + "safeName": "TYPE" + }, + "pascalCase": { + "unsafeName": "Type", + "safeName": "Type" + } + } + }, + "types": { + "message": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamMessageVariant", + "discriminantValue": { + "wireValue": "message", "name": { - "originalName": "id", + "originalName": "message", "camelCase": { - "unsafeName": "id", - "safeName": "id" + "unsafeName": "message", + "safeName": "message" }, - "snakeCase": { - "unsafeName": "id", - "safeName": "id" + "snakeCase": { + "unsafeName": "message", + "safeName": "message" }, "screamingSnakeCase": { - "unsafeName": "ID", - "safeName": "ID" + "unsafeName": "MESSAGE", + "safeName": "MESSAGE" }, "pascalCase": { - "unsafeName": "ID", - "safeName": "ID" + "unsafeName": "Message", + "safeName": "Message" } } }, - "typeReference": { - "type": "primitive", - "value": "STRING" - }, - "propertyAccess": null, - "variable": null + "properties": [] }, - { - "name": { - "wireValue": "name", + "interrupt": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamInterruptVariant", + "discriminantValue": { + "wireValue": "interrupt", "name": { - "originalName": "name", + "originalName": "interrupt", "camelCase": { - "unsafeName": "name", - "safeName": "name" + "unsafeName": "interrupt", + "safeName": "interrupt" }, "snakeCase": { - "unsafeName": "name", - "safeName": "name" + "unsafeName": "interrupt", + "safeName": "interrupt" }, "screamingSnakeCase": { - "unsafeName": "NAME", - "safeName": "NAME" + "unsafeName": "INTERRUPT", + "safeName": "INTERRUPT" }, "pascalCase": { - "unsafeName": "Name", - "safeName": "Name" + "unsafeName": "Interrupt", + "safeName": "Interrupt" } } }, - "typeReference": { - "type": "primitive", - "value": "STRING" - }, - "propertyAccess": null, - "variable": null + "properties": [] }, - { - "name": { - "wireValue": "event", + "compact": { + "type": "samePropertiesAsObject", + "typeId": "type_:UnionStreamCompactVariant", + "discriminantValue": { + "wireValue": "compact", "name": { - "originalName": "event", + "originalName": "compact", "camelCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "compact", + "safeName": "compact" }, "snakeCase": { - "unsafeName": "event", - "safeName": "event" + "unsafeName": "compact", + "safeName": "compact" }, "screamingSnakeCase": { - "unsafeName": "EVENT", - "safeName": "EVENT" + "unsafeName": "COMPACT", + "safeName": "COMPACT" }, "pascalCase": { - "unsafeName": "Event", - "safeName": "Event" + "unsafeName": "Compact", + "safeName": "Compact" } } }, - "typeReference": { - "type": "primitive", - "value": "STRING" - }, - "propertyAccess": null, - "variable": null + "properties": [] } - ], - "extends": null, - "additionalProperties": false - }, - "type_:HeartbeatPayload": { - "type": "object", + } + } + }, + "headers": [], + "endpoints": { + "endpoint_.streamProtocolNoCollision": { + "auth": null, "declaration": { "name": { - "originalName": "HeartbeatPayload", + "originalName": "streamProtocolNoCollision", "camelCase": { - "unsafeName": "heartbeatPayload", - "safeName": "heartbeatPayload" + "unsafeName": "streamProtocolNoCollision", + "safeName": "streamProtocolNoCollision" }, "snakeCase": { - "unsafeName": "heartbeat_payload", - "safeName": "heartbeat_payload" + "unsafeName": "stream_protocol_no_collision", + "safeName": "stream_protocol_no_collision" }, "screamingSnakeCase": { - "unsafeName": "HEARTBEAT_PAYLOAD", - "safeName": "HEARTBEAT_PAYLOAD" + "unsafeName": "STREAM_PROTOCOL_NO_COLLISION", + "safeName": "STREAM_PROTOCOL_NO_COLLISION" }, "pascalCase": { - "unsafeName": "HeartbeatPayload", - "safeName": "HeartbeatPayload" + "unsafeName": "StreamProtocolNoCollision", + "safeName": "StreamProtocolNoCollision" } }, "fernFilepath": { @@ -5701,64 +15043,46 @@ "file": null } }, - "properties": [ - { - "name": { - "wireValue": "timestamp", - "name": { - "originalName": "timestamp", - "camelCase": { - "unsafeName": "timestamp", - "safeName": "timestamp" - }, - "snakeCase": { - "unsafeName": "timestamp", - "safeName": "timestamp" - }, - "screamingSnakeCase": { - "unsafeName": "TIMESTAMP", - "safeName": "TIMESTAMP" - }, - "pascalCase": { - "unsafeName": "Timestamp", - "safeName": "Timestamp" - } - } - }, - "typeReference": { - "type": "optional", - "value": { - "type": "primitive", - "value": "DATE_TIME" - } - }, - "propertyAccess": null, - "variable": null + "location": { + "method": "POST", + "path": "/stream/protocol-no-collision" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } } - ], - "extends": null, - "additionalProperties": false + }, + "response": { + "type": "streaming" + }, + "examples": null }, - "type_:EntityEventPayloadEventType": { - "type": "enum", + "endpoint_.streamProtocolCollision": { + "auth": null, "declaration": { "name": { - "originalName": "EntityEventPayloadEventType", + "originalName": "streamProtocolCollision", "camelCase": { - "unsafeName": "entityEventPayloadEventType", - "safeName": "entityEventPayloadEventType" + "unsafeName": "streamProtocolCollision", + "safeName": "streamProtocolCollision" }, "snakeCase": { - "unsafeName": "entity_event_payload_event_type", - "safeName": "entity_event_payload_event_type" + "unsafeName": "stream_protocol_collision", + "safeName": "stream_protocol_collision" }, "screamingSnakeCase": { - "unsafeName": "ENTITY_EVENT_PAYLOAD_EVENT_TYPE", - "safeName": "ENTITY_EVENT_PAYLOAD_EVENT_TYPE" + "unsafeName": "STREAM_PROTOCOL_COLLISION", + "safeName": "STREAM_PROTOCOL_COLLISION" }, "pascalCase": { - "unsafeName": "EntityEventPayloadEventType", - "safeName": "EntityEventPayloadEventType" + "unsafeName": "StreamProtocolCollision", + "safeName": "StreamProtocolCollision" } }, "fernFilepath": { @@ -5767,117 +15091,46 @@ "file": null } }, - "values": [ - { - "wireValue": "CREATED", - "name": { - "originalName": "CREATED", - "camelCase": { - "unsafeName": "created", - "safeName": "created" - }, - "snakeCase": { - "unsafeName": "created", - "safeName": "created" - }, - "screamingSnakeCase": { - "unsafeName": "CREATED", - "safeName": "CREATED" - }, - "pascalCase": { - "unsafeName": "Created", - "safeName": "Created" - } - } - }, - { - "wireValue": "UPDATED", - "name": { - "originalName": "UPDATED", - "camelCase": { - "unsafeName": "updated", - "safeName": "updated" - }, - "snakeCase": { - "unsafeName": "updated", - "safeName": "updated" - }, - "screamingSnakeCase": { - "unsafeName": "UPDATED", - "safeName": "UPDATED" - }, - "pascalCase": { - "unsafeName": "Updated", - "safeName": "Updated" - } - } - }, - { - "wireValue": "DELETED", - "name": { - "originalName": "DELETED", - "camelCase": { - "unsafeName": "deleted", - "safeName": "deleted" - }, - "snakeCase": { - "unsafeName": "deleted", - "safeName": "deleted" - }, - "screamingSnakeCase": { - "unsafeName": "DELETED", - "safeName": "DELETED" - }, - "pascalCase": { - "unsafeName": "Deleted", - "safeName": "Deleted" - } - } - }, - { - "wireValue": "PREEXISTING", - "name": { - "originalName": "PREEXISTING", - "camelCase": { - "unsafeName": "preexisting", - "safeName": "preexisting" - }, - "snakeCase": { - "unsafeName": "preexisting", - "safeName": "preexisting" - }, - "screamingSnakeCase": { - "unsafeName": "PREEXISTING", - "safeName": "PREEXISTING" - }, - "pascalCase": { - "unsafeName": "Preexisting", - "safeName": "Preexisting" - } + "location": { + "method": "POST", + "path": "/stream/protocol-collision" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" } } - ] + }, + "response": { + "type": "streaming" + }, + "examples": null }, - "type_:EntityEventPayload": { - "type": "object", + "endpoint_.streamDataContext": { + "auth": null, "declaration": { "name": { - "originalName": "EntityEventPayload", + "originalName": "streamDataContext", "camelCase": { - "unsafeName": "entityEventPayload", - "safeName": "entityEventPayload" + "unsafeName": "streamDataContext", + "safeName": "streamDataContext" }, "snakeCase": { - "unsafeName": "entity_event_payload", - "safeName": "entity_event_payload" + "unsafeName": "stream_data_context", + "safeName": "stream_data_context" }, "screamingSnakeCase": { - "unsafeName": "ENTITY_EVENT_PAYLOAD", - "safeName": "ENTITY_EVENT_PAYLOAD" + "unsafeName": "STREAM_DATA_CONTEXT", + "safeName": "STREAM_DATA_CONTEXT" }, "pascalCase": { - "unsafeName": "EntityEventPayload", - "safeName": "EntityEventPayload" + "unsafeName": "StreamDataContext", + "safeName": "StreamDataContext" } }, "fernFilepath": { @@ -5886,130 +15139,94 @@ "file": null } }, - "properties": [ - { - "name": { - "wireValue": "entityId", - "name": { - "originalName": "entityId", - "camelCase": { - "unsafeName": "entityID", - "safeName": "entityID" - }, - "snakeCase": { - "unsafeName": "entity_id", - "safeName": "entity_id" - }, - "screamingSnakeCase": { - "unsafeName": "ENTITY_ID", - "safeName": "ENTITY_ID" - }, - "pascalCase": { - "unsafeName": "EntityID", - "safeName": "EntityID" - } - } - }, - "typeReference": { - "type": "optional", - "value": { - "type": "primitive", - "value": "STRING" - } + "location": { + "method": "POST", + "path": "/stream/data-context" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null + }, + "endpoint_.streamNoContext": { + "auth": null, + "declaration": { + "name": { + "originalName": "streamNoContext", + "camelCase": { + "unsafeName": "streamNoContext", + "safeName": "streamNoContext" }, - "propertyAccess": null, - "variable": null - }, - { - "name": { - "wireValue": "eventType", - "name": { - "originalName": "eventType", - "camelCase": { - "unsafeName": "eventType", - "safeName": "eventType" - }, - "snakeCase": { - "unsafeName": "event_type", - "safeName": "event_type" - }, - "screamingSnakeCase": { - "unsafeName": "EVENT_TYPE", - "safeName": "EVENT_TYPE" - }, - "pascalCase": { - "unsafeName": "EventType", - "safeName": "EventType" - } - } + "snakeCase": { + "unsafeName": "stream_no_context", + "safeName": "stream_no_context" }, - "typeReference": { - "type": "optional", - "value": { - "type": "named", - "value": "type_:EntityEventPayloadEventType" - } + "screamingSnakeCase": { + "unsafeName": "STREAM_NO_CONTEXT", + "safeName": "STREAM_NO_CONTEXT" }, - "propertyAccess": null, - "variable": null + "pascalCase": { + "unsafeName": "StreamNoContext", + "safeName": "StreamNoContext" + } }, - { - "name": { - "wireValue": "updatedTime", - "name": { - "originalName": "updatedTime", - "camelCase": { - "unsafeName": "updatedTime", - "safeName": "updatedTime" - }, - "snakeCase": { - "unsafeName": "updated_time", - "safeName": "updated_time" - }, - "screamingSnakeCase": { - "unsafeName": "UPDATED_TIME", - "safeName": "UPDATED_TIME" - }, - "pascalCase": { - "unsafeName": "UpdatedTime", - "safeName": "UpdatedTime" - } - } - }, - "typeReference": { - "type": "optional", - "value": { - "type": "primitive", - "value": "DATE_TIME" - } - }, - "propertyAccess": null, - "variable": null + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null } - ], - "extends": null, - "additionalProperties": false + }, + "location": { + "method": "POST", + "path": "/stream/no-context" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null }, - "type_:ProtocolHeartbeat": { - "type": "object", + "endpoint_.streamProtocolWithFlatSchema": { + "auth": null, "declaration": { "name": { - "originalName": "ProtocolHeartbeat", + "originalName": "streamProtocolWithFlatSchema", "camelCase": { - "unsafeName": "protocolHeartbeat", - "safeName": "protocolHeartbeat" + "unsafeName": "streamProtocolWithFlatSchema", + "safeName": "streamProtocolWithFlatSchema" }, "snakeCase": { - "unsafeName": "protocol_heartbeat", - "safeName": "protocol_heartbeat" + "unsafeName": "stream_protocol_with_flat_schema", + "safeName": "stream_protocol_with_flat_schema" }, "screamingSnakeCase": { - "unsafeName": "PROTOCOL_HEARTBEAT", - "safeName": "PROTOCOL_HEARTBEAT" + "unsafeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA", + "safeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA" }, "pascalCase": { - "unsafeName": "ProtocolHeartbeat", - "safeName": "ProtocolHeartbeat" + "unsafeName": "StreamProtocolWithFlatSchema", + "safeName": "StreamProtocolWithFlatSchema" } }, "fernFilepath": { @@ -6018,30 +15235,46 @@ "file": null } }, - "properties": [], - "extends": null, - "additionalProperties": false + "location": { + "method": "POST", + "path": "/stream/protocol-with-flat-schema" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } + } + }, + "response": { + "type": "streaming" + }, + "examples": null }, - "type_:ProtocolStringEvent": { - "type": "object", + "endpoint_.streamDataContextWithEnvelopeSchema": { + "auth": null, "declaration": { "name": { - "originalName": "ProtocolStringEvent", + "originalName": "streamDataContextWithEnvelopeSchema", "camelCase": { - "unsafeName": "protocolStringEvent", - "safeName": "protocolStringEvent" + "unsafeName": "streamDataContextWithEnvelopeSchema", + "safeName": "streamDataContextWithEnvelopeSchema" }, "snakeCase": { - "unsafeName": "protocol_string_event", - "safeName": "protocol_string_event" + "unsafeName": "stream_data_context_with_envelope_schema", + "safeName": "stream_data_context_with_envelope_schema" }, "screamingSnakeCase": { - "unsafeName": "PROTOCOL_STRING_EVENT", - "safeName": "PROTOCOL_STRING_EVENT" + "unsafeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA", + "safeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA" }, "pascalCase": { - "unsafeName": "ProtocolStringEvent", - "safeName": "ProtocolStringEvent" + "unsafeName": "StreamDataContextWithEnvelopeSchema", + "safeName": "StreamDataContextWithEnvelopeSchema" } }, "fernFilepath": { @@ -6050,61 +15283,46 @@ "file": null } }, - "properties": [ - { - "name": { - "wireValue": "data", - "name": { - "originalName": "data", - "camelCase": { - "unsafeName": "data", - "safeName": "data" - }, - "snakeCase": { - "unsafeName": "data", - "safeName": "data" - }, - "screamingSnakeCase": { - "unsafeName": "DATA", - "safeName": "DATA" - }, - "pascalCase": { - "unsafeName": "Data", - "safeName": "Data" - } - } - }, - "typeReference": { - "type": "primitive", - "value": "STRING" - }, - "propertyAccess": null, - "variable": null + "location": { + "method": "POST", + "path": "/stream/data-context-with-envelope-schema" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } } - ], - "extends": null, - "additionalProperties": false + }, + "response": { + "type": "streaming" + }, + "examples": null }, - "type_:ProtocolNumberEvent": { - "type": "object", + "endpoint_.streamOasSpecNative": { + "auth": null, "declaration": { "name": { - "originalName": "ProtocolNumberEvent", + "originalName": "streamOasSpecNative", "camelCase": { - "unsafeName": "protocolNumberEvent", - "safeName": "protocolNumberEvent" + "unsafeName": "streamOasSpecNative", + "safeName": "streamOasSpecNative" }, "snakeCase": { - "unsafeName": "protocol_number_event", - "safeName": "protocol_number_event" + "unsafeName": "stream_oas_spec_native", + "safeName": "stream_oas_spec_native" }, "screamingSnakeCase": { - "unsafeName": "PROTOCOL_NUMBER_EVENT", - "safeName": "PROTOCOL_NUMBER_EVENT" + "unsafeName": "STREAM_OAS_SPEC_NATIVE", + "safeName": "STREAM_OAS_SPEC_NATIVE" }, "pascalCase": { - "unsafeName": "ProtocolNumberEvent", - "safeName": "ProtocolNumberEvent" + "unsafeName": "StreamOasSpecNative", + "safeName": "StreamOasSpecNative" } }, "fernFilepath": { @@ -6113,61 +15331,46 @@ "file": null } }, - "properties": [ - { - "name": { - "wireValue": "data", - "name": { - "originalName": "data", - "camelCase": { - "unsafeName": "data", - "safeName": "data" - }, - "snakeCase": { - "unsafeName": "data", - "safeName": "data" - }, - "screamingSnakeCase": { - "unsafeName": "DATA", - "safeName": "DATA" - }, - "pascalCase": { - "unsafeName": "Data", - "safeName": "Data" - } - } - }, - "typeReference": { - "type": "primitive", - "value": "DOUBLE" - }, - "propertyAccess": null, - "variable": null + "location": { + "method": "POST", + "path": "/stream/oas-spec-native" + }, + "request": { + "type": "body", + "pathParameters": [], + "body": { + "type": "typeReference", + "value": { + "type": "named", + "value": "type_:StreamRequest" + } } - ], - "extends": null, - "additionalProperties": false + }, + "response": { + "type": "streaming" + }, + "examples": null }, - "type_:ProtocolObjectEvent": { - "type": "object", + "endpoint_.streamXFernStreamingCondition_stream": { + "auth": null, "declaration": { "name": { - "originalName": "ProtocolObjectEvent", + "originalName": "streamXFernStreamingCondition_stream", "camelCase": { - "unsafeName": "protocolObjectEvent", - "safeName": "protocolObjectEvent" + "unsafeName": "streamXFernStreamingConditionStream", + "safeName": "streamXFernStreamingConditionStream" }, "snakeCase": { - "unsafeName": "protocol_object_event", - "safeName": "protocol_object_event" + "unsafeName": "stream_x_fern_streaming_condition_stream", + "safeName": "stream_x_fern_streaming_condition_stream" }, "screamingSnakeCase": { - "unsafeName": "PROTOCOL_OBJECT_EVENT", - "safeName": "PROTOCOL_OBJECT_EVENT" + "unsafeName": "STREAM_X_FERN_STREAMING_CONDITION_STREAM", + "safeName": "STREAM_X_FERN_STREAMING_CONDITION_STREAM" }, "pascalCase": { - "unsafeName": "ProtocolObjectEvent", - "safeName": "ProtocolObjectEvent" + "unsafeName": "StreamXFernStreamingConditionStream", + "safeName": "StreamXFernStreamingConditionStream" } }, "fernFilepath": { @@ -6176,61 +15379,139 @@ "file": null } }, - "properties": [ - { + "location": { + "method": "POST", + "path": "/stream/x-fern-streaming-condition" + }, + "request": { + "type": "inlined", + "declaration": { "name": { - "wireValue": "data", - "name": { - "originalName": "data", - "camelCase": { - "unsafeName": "data", - "safeName": "data" + "originalName": "StreamXFernStreamingConditionStreamRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingConditionStreamRequest", + "safeName": "streamXFernStreamingConditionStreamRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_condition_stream_request", + "safeName": "stream_x_fern_streaming_condition_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_CONDITION_STREAM_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_CONDITION_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingConditionStreamRequest", + "safeName": "StreamXFernStreamingConditionStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "pathParameters": [], + "queryParameters": [], + "headers": [], + "body": { + "type": "properties", + "value": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } }, - "snakeCase": { - "unsafeName": "data", - "safeName": "data" + "typeReference": { + "type": "primitive", + "value": "STRING" }, - "screamingSnakeCase": { - "unsafeName": "DATA", - "safeName": "DATA" + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } }, - "pascalCase": { - "unsafeName": "Data", - "safeName": "Data" - } + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null } - }, - "typeReference": { - "type": "named", - "value": "type_:StatusPayload" - }, - "propertyAccess": null, - "variable": null + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } - ], - "extends": null, - "additionalProperties": false + }, + "response": { + "type": "streaming" + }, + "examples": null }, - "type_:ProtocolCollisionObjectEvent": { - "type": "object", + "endpoint_.streamXFernStreamingCondition": { + "auth": null, "declaration": { "name": { - "originalName": "ProtocolCollisionObjectEvent", + "originalName": "streamXFernStreamingCondition", "camelCase": { - "unsafeName": "protocolCollisionObjectEvent", - "safeName": "protocolCollisionObjectEvent" + "unsafeName": "streamXFernStreamingCondition", + "safeName": "streamXFernStreamingCondition" }, "snakeCase": { - "unsafeName": "protocol_collision_object_event", - "safeName": "protocol_collision_object_event" + "unsafeName": "stream_x_fern_streaming_condition", + "safeName": "stream_x_fern_streaming_condition" }, "screamingSnakeCase": { - "unsafeName": "PROTOCOL_COLLISION_OBJECT_EVENT", - "safeName": "PROTOCOL_COLLISION_OBJECT_EVENT" + "unsafeName": "STREAM_X_FERN_STREAMING_CONDITION", + "safeName": "STREAM_X_FERN_STREAMING_CONDITION" }, "pascalCase": { - "unsafeName": "ProtocolCollisionObjectEvent", - "safeName": "ProtocolCollisionObjectEvent" + "unsafeName": "StreamXFernStreamingCondition", + "safeName": "StreamXFernStreamingCondition" } }, "fernFilepath": { @@ -6239,61 +15520,139 @@ "file": null } }, - "properties": [ - { + "location": { + "method": "POST", + "path": "/stream/x-fern-streaming-condition" + }, + "request": { + "type": "inlined", + "declaration": { "name": { - "wireValue": "data", - "name": { - "originalName": "data", - "camelCase": { - "unsafeName": "data", - "safeName": "data" + "originalName": "StreamXFernStreamingConditionRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingConditionRequest", + "safeName": "streamXFernStreamingConditionRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_condition_request", + "safeName": "stream_x_fern_streaming_condition_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_CONDITION_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_CONDITION_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingConditionRequest", + "safeName": "StreamXFernStreamingConditionRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "pathParameters": [], + "queryParameters": [], + "headers": [], + "body": { + "type": "properties", + "value": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } }, - "snakeCase": { - "unsafeName": "data", - "safeName": "data" + "typeReference": { + "type": "primitive", + "value": "STRING" }, - "screamingSnakeCase": { - "unsafeName": "DATA", - "safeName": "DATA" + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } }, - "pascalCase": { - "unsafeName": "Data", - "safeName": "Data" - } + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null } - }, - "typeReference": { - "type": "named", - "value": "type_:ObjectPayloadWithEventField" - }, - "propertyAccess": null, - "variable": null + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } - ], - "extends": null, - "additionalProperties": false + }, + "response": { + "type": "json" + }, + "examples": null }, - "type_:DataContextHeartbeat": { - "type": "object", + "endpoint_.streamXFernStreamingSharedSchema_stream": { + "auth": null, "declaration": { "name": { - "originalName": "DataContextHeartbeat", + "originalName": "streamXFernStreamingSharedSchema_stream", "camelCase": { - "unsafeName": "dataContextHeartbeat", - "safeName": "dataContextHeartbeat" + "unsafeName": "streamXFernStreamingSharedSchemaStream", + "safeName": "streamXFernStreamingSharedSchemaStream" }, "snakeCase": { - "unsafeName": "data_context_heartbeat", - "safeName": "data_context_heartbeat" + "unsafeName": "stream_x_fern_streaming_shared_schema_stream", + "safeName": "stream_x_fern_streaming_shared_schema_stream" }, "screamingSnakeCase": { - "unsafeName": "DATA_CONTEXT_HEARTBEAT", - "safeName": "DATA_CONTEXT_HEARTBEAT" + "unsafeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_STREAM", + "safeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_STREAM" }, "pascalCase": { - "unsafeName": "DataContextHeartbeat", - "safeName": "DataContextHeartbeat" + "unsafeName": "StreamXFernStreamingSharedSchemaStream", + "safeName": "StreamXFernStreamingSharedSchemaStream" } }, "fernFilepath": { @@ -6302,66 +15661,169 @@ "file": null } }, - "properties": [ - { + "location": { + "method": "POST", + "path": "/stream/x-fern-streaming-shared-schema" + }, + "request": { + "type": "inlined", + "declaration": { "name": { - "wireValue": "timestamp", - "name": { - "originalName": "timestamp", - "camelCase": { - "unsafeName": "timestamp", - "safeName": "timestamp" + "originalName": "StreamXFernStreamingSharedSchemaStreamRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingSharedSchemaStreamRequest", + "safeName": "streamXFernStreamingSharedSchemaStreamRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_shared_schema_stream_request", + "safeName": "stream_x_fern_streaming_shared_schema_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_STREAM_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingSharedSchemaStreamRequest", + "safeName": "StreamXFernStreamingSharedSchemaStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, + "pathParameters": [], + "queryParameters": [], + "headers": [], + "body": { + "type": "properties", + "value": [ + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } }, - "snakeCase": { - "unsafeName": "timestamp", - "safeName": "timestamp" + "typeReference": { + "type": "primitive", + "value": "STRING" }, - "screamingSnakeCase": { - "unsafeName": "TIMESTAMP", - "safeName": "TIMESTAMP" + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "model", + "name": { + "originalName": "model", + "camelCase": { + "unsafeName": "model", + "safeName": "model" + }, + "snakeCase": { + "unsafeName": "model", + "safeName": "model" + }, + "screamingSnakeCase": { + "unsafeName": "MODEL", + "safeName": "MODEL" + }, + "pascalCase": { + "unsafeName": "Model", + "safeName": "Model" + } + } }, - "pascalCase": { - "unsafeName": "Timestamp", - "safeName": "Timestamp" - } - } - }, - "typeReference": { - "type": "optional", - "value": { - "type": "primitive", - "value": "DATE_TIME" + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null } - }, - "propertyAccess": null, - "variable": null + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } - ], - "extends": [ - "type_:HeartbeatPayload" - ], - "additionalProperties": false + }, + "response": { + "type": "streaming" + }, + "examples": null }, - "type_:DataContextEntityEvent": { - "type": "object", + "endpoint_.streamXFernStreamingSharedSchema": { + "auth": null, "declaration": { "name": { - "originalName": "DataContextEntityEvent", + "originalName": "streamXFernStreamingSharedSchema", "camelCase": { - "unsafeName": "dataContextEntityEvent", - "safeName": "dataContextEntityEvent" + "unsafeName": "streamXFernStreamingSharedSchema", + "safeName": "streamXFernStreamingSharedSchema" }, "snakeCase": { - "unsafeName": "data_context_entity_event", - "safeName": "data_context_entity_event" + "unsafeName": "stream_x_fern_streaming_shared_schema", + "safeName": "stream_x_fern_streaming_shared_schema" }, "screamingSnakeCase": { - "unsafeName": "DATA_CONTEXT_ENTITY_EVENT", - "safeName": "DATA_CONTEXT_ENTITY_EVENT" + "unsafeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA", + "safeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA" }, "pascalCase": { - "unsafeName": "DataContextEntityEvent", - "safeName": "DataContextEntityEvent" + "unsafeName": "StreamXFernStreamingSharedSchema", + "safeName": "StreamXFernStreamingSharedSchema" } }, "fernFilepath": { @@ -6370,135 +15832,169 @@ "file": null } }, - "properties": [ - { + "location": { + "method": "POST", + "path": "/stream/x-fern-streaming-shared-schema" + }, + "request": { + "type": "inlined", + "declaration": { "name": { - "wireValue": "entityId", - "name": { - "originalName": "entityId", - "camelCase": { - "unsafeName": "entityID", - "safeName": "entityID" - }, - "snakeCase": { - "unsafeName": "entity_id", - "safeName": "entity_id" - }, - "screamingSnakeCase": { - "unsafeName": "ENTITY_ID", - "safeName": "ENTITY_ID" - }, - "pascalCase": { - "unsafeName": "EntityID", - "safeName": "EntityID" - } - } - }, - "typeReference": { - "type": "optional", - "value": { - "type": "primitive", - "value": "STRING" + "originalName": "StreamXFernStreamingSharedSchemaRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingSharedSchemaRequest", + "safeName": "streamXFernStreamingSharedSchemaRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_shared_schema_request", + "safeName": "stream_x_fern_streaming_shared_schema_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_SHARED_SCHEMA_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingSharedSchemaRequest", + "safeName": "StreamXFernStreamingSharedSchemaRequest" } }, - "propertyAccess": null, - "variable": null + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } }, - { - "name": { - "wireValue": "eventType", - "name": { - "originalName": "eventType", - "camelCase": { - "unsafeName": "eventType", - "safeName": "eventType" + "pathParameters": [], + "queryParameters": [], + "headers": [], + "body": { + "type": "properties", + "value": [ + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } }, - "snakeCase": { - "unsafeName": "event_type", - "safeName": "event_type" + "typeReference": { + "type": "primitive", + "value": "STRING" }, - "screamingSnakeCase": { - "unsafeName": "EVENT_TYPE", - "safeName": "EVENT_TYPE" + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "model", + "name": { + "originalName": "model", + "camelCase": { + "unsafeName": "model", + "safeName": "model" + }, + "snakeCase": { + "unsafeName": "model", + "safeName": "model" + }, + "screamingSnakeCase": { + "unsafeName": "MODEL", + "safeName": "MODEL" + }, + "pascalCase": { + "unsafeName": "Model", + "safeName": "Model" + } + } }, - "pascalCase": { - "unsafeName": "EventType", - "safeName": "EventType" - } - } - }, - "typeReference": { - "type": "optional", - "value": { - "type": "named", - "value": "type_:EntityEventPayloadEventType" - } - }, - "propertyAccess": null, - "variable": null - }, - { - "name": { - "wireValue": "updatedTime", - "name": { - "originalName": "updatedTime", - "camelCase": { - "unsafeName": "updatedTime", - "safeName": "updatedTime" + "typeReference": { + "type": "primitive", + "value": "STRING" }, - "snakeCase": { - "unsafeName": "updated_time", - "safeName": "updated_time" + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } }, - "screamingSnakeCase": { - "unsafeName": "UPDATED_TIME", - "safeName": "UPDATED_TIME" + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } }, - "pascalCase": { - "unsafeName": "UpdatedTime", - "safeName": "UpdatedTime" - } - } - }, - "typeReference": { - "type": "optional", - "value": { - "type": "primitive", - "value": "DATE_TIME" + "propertyAccess": null, + "variable": null } - }, - "propertyAccess": null, - "variable": null + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } - ], - "extends": [ - "type_:EntityEventPayload" - ], - "additionalProperties": false - } - }, - "headers": [], - "endpoints": { - "endpoint_.streamProtocolNoCollision": { + }, + "response": { + "type": "json" + }, + "examples": null + }, + "endpoint_.validateCompletion": { "auth": null, "declaration": { "name": { - "originalName": "streamProtocolNoCollision", + "originalName": "validateCompletion", "camelCase": { - "unsafeName": "streamProtocolNoCollision", - "safeName": "streamProtocolNoCollision" + "unsafeName": "validateCompletion", + "safeName": "validateCompletion" }, "snakeCase": { - "unsafeName": "stream_protocol_no_collision", - "safeName": "stream_protocol_no_collision" + "unsafeName": "validate_completion", + "safeName": "validate_completion" }, "screamingSnakeCase": { - "unsafeName": "STREAM_PROTOCOL_NO_COLLISION", - "safeName": "STREAM_PROTOCOL_NO_COLLISION" + "unsafeName": "VALIDATE_COMPLETION", + "safeName": "VALIDATE_COMPLETION" }, "pascalCase": { - "unsafeName": "StreamProtocolNoCollision", - "safeName": "StreamProtocolNoCollision" + "unsafeName": "ValidateCompletion", + "safeName": "ValidateCompletion" } }, "fernFilepath": { @@ -6509,44 +16005,167 @@ }, "location": { "method": "POST", - "path": "/stream/protocol-no-collision" + "path": "/validate-completion" }, "request": { - "type": "body", + "type": "inlined", + "declaration": { + "name": { + "originalName": "SharedCompletionRequest", + "camelCase": { + "unsafeName": "sharedCompletionRequest", + "safeName": "sharedCompletionRequest" + }, + "snakeCase": { + "unsafeName": "shared_completion_request", + "safeName": "shared_completion_request" + }, + "screamingSnakeCase": { + "unsafeName": "SHARED_COMPLETION_REQUEST", + "safeName": "SHARED_COMPLETION_REQUEST" + }, + "pascalCase": { + "unsafeName": "SharedCompletionRequest", + "safeName": "SharedCompletionRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, "pathParameters": [], + "queryParameters": [], + "headers": [], "body": { - "type": "typeReference", - "value": { - "type": "named", - "value": "type_:StreamRequest" - } + "type": "properties", + "value": [ + { + "name": { + "wireValue": "prompt", + "name": { + "originalName": "prompt", + "camelCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "snakeCase": { + "unsafeName": "prompt", + "safeName": "prompt" + }, + "screamingSnakeCase": { + "unsafeName": "PROMPT", + "safeName": "PROMPT" + }, + "pascalCase": { + "unsafeName": "Prompt", + "safeName": "Prompt" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "model", + "name": { + "originalName": "model", + "camelCase": { + "unsafeName": "model", + "safeName": "model" + }, + "snakeCase": { + "unsafeName": "model", + "safeName": "model" + }, + "screamingSnakeCase": { + "unsafeName": "MODEL", + "safeName": "MODEL" + }, + "pascalCase": { + "unsafeName": "Model", + "safeName": "Model" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "optional", + "value": { + "type": "primitive", + "value": "BOOLEAN" + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } }, "response": { - "type": "streaming" + "type": "json" }, "examples": null }, - "endpoint_.streamProtocolCollision": { + "endpoint_.streamXFernStreamingUnion_stream": { "auth": null, "declaration": { "name": { - "originalName": "streamProtocolCollision", + "originalName": "streamXFernStreamingUnion_stream", "camelCase": { - "unsafeName": "streamProtocolCollision", - "safeName": "streamProtocolCollision" + "unsafeName": "streamXFernStreamingUnionStream", + "safeName": "streamXFernStreamingUnionStream" }, "snakeCase": { - "unsafeName": "stream_protocol_collision", - "safeName": "stream_protocol_collision" + "unsafeName": "stream_x_fern_streaming_union_stream", + "safeName": "stream_x_fern_streaming_union_stream" }, "screamingSnakeCase": { - "unsafeName": "STREAM_PROTOCOL_COLLISION", - "safeName": "STREAM_PROTOCOL_COLLISION" + "unsafeName": "STREAM_X_FERN_STREAMING_UNION_STREAM", + "safeName": "STREAM_X_FERN_STREAMING_UNION_STREAM" }, "pascalCase": { - "unsafeName": "StreamProtocolCollision", - "safeName": "StreamProtocolCollision" + "unsafeName": "StreamXFernStreamingUnionStream", + "safeName": "StreamXFernStreamingUnionStream" } }, "fernFilepath": { @@ -6557,7 +16176,7 @@ }, "location": { "method": "POST", - "path": "/stream/protocol-collision" + "path": "/stream/x-fern-streaming-union" }, "request": { "type": "body", @@ -6566,7 +16185,7 @@ "type": "typeReference", "value": { "type": "named", - "value": "type_:StreamRequest" + "value": "type_:StreamXFernStreamingUnionStreamRequest" } } }, @@ -6575,26 +16194,26 @@ }, "examples": null }, - "endpoint_.streamDataContext": { + "endpoint_.streamXFernStreamingUnion": { "auth": null, "declaration": { "name": { - "originalName": "streamDataContext", + "originalName": "streamXFernStreamingUnion", "camelCase": { - "unsafeName": "streamDataContext", - "safeName": "streamDataContext" + "unsafeName": "streamXFernStreamingUnion", + "safeName": "streamXFernStreamingUnion" }, "snakeCase": { - "unsafeName": "stream_data_context", - "safeName": "stream_data_context" + "unsafeName": "stream_x_fern_streaming_union", + "safeName": "stream_x_fern_streaming_union" }, "screamingSnakeCase": { - "unsafeName": "STREAM_DATA_CONTEXT", - "safeName": "STREAM_DATA_CONTEXT" + "unsafeName": "STREAM_X_FERN_STREAMING_UNION", + "safeName": "STREAM_X_FERN_STREAMING_UNION" }, "pascalCase": { - "unsafeName": "StreamDataContext", - "safeName": "StreamDataContext" + "unsafeName": "StreamXFernStreamingUnion", + "safeName": "StreamXFernStreamingUnion" } }, "fernFilepath": { @@ -6605,7 +16224,7 @@ }, "location": { "method": "POST", - "path": "/stream/data-context" + "path": "/stream/x-fern-streaming-union" }, "request": { "type": "body", @@ -6614,35 +16233,35 @@ "type": "typeReference", "value": { "type": "named", - "value": "type_:StreamRequest" + "value": "type_:StreamXFernStreamingUnionRequest" } } }, "response": { - "type": "streaming" + "type": "json" }, "examples": null }, - "endpoint_.streamNoContext": { + "endpoint_.validateUnionRequest": { "auth": null, "declaration": { "name": { - "originalName": "streamNoContext", + "originalName": "validateUnionRequest", "camelCase": { - "unsafeName": "streamNoContext", - "safeName": "streamNoContext" + "unsafeName": "validateUnionRequest", + "safeName": "validateUnionRequest" }, "snakeCase": { - "unsafeName": "stream_no_context", - "safeName": "stream_no_context" + "unsafeName": "validate_union_request", + "safeName": "validate_union_request" }, "screamingSnakeCase": { - "unsafeName": "STREAM_NO_CONTEXT", - "safeName": "STREAM_NO_CONTEXT" + "unsafeName": "VALIDATE_UNION_REQUEST", + "safeName": "VALIDATE_UNION_REQUEST" }, "pascalCase": { - "unsafeName": "StreamNoContext", - "safeName": "StreamNoContext" + "unsafeName": "ValidateUnionRequest", + "safeName": "ValidateUnionRequest" } }, "fernFilepath": { @@ -6653,7 +16272,7 @@ }, "location": { "method": "POST", - "path": "/stream/no-context" + "path": "/validate-union-request" }, "request": { "type": "body", @@ -6662,35 +16281,35 @@ "type": "typeReference", "value": { "type": "named", - "value": "type_:StreamRequest" + "value": "type_:UnionStreamRequestBase" } } }, "response": { - "type": "streaming" + "type": "json" }, "examples": null }, - "endpoint_.streamProtocolWithFlatSchema": { + "endpoint_.streamXFernStreamingNullableCondition_stream": { "auth": null, "declaration": { "name": { - "originalName": "streamProtocolWithFlatSchema", + "originalName": "streamXFernStreamingNullableCondition_stream", "camelCase": { - "unsafeName": "streamProtocolWithFlatSchema", - "safeName": "streamProtocolWithFlatSchema" + "unsafeName": "streamXFernStreamingNullableConditionStream", + "safeName": "streamXFernStreamingNullableConditionStream" }, "snakeCase": { - "unsafeName": "stream_protocol_with_flat_schema", - "safeName": "stream_protocol_with_flat_schema" + "unsafeName": "stream_x_fern_streaming_nullable_condition_stream", + "safeName": "stream_x_fern_streaming_nullable_condition_stream" }, "screamingSnakeCase": { - "unsafeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA", - "safeName": "STREAM_PROTOCOL_WITH_FLAT_SCHEMA" + "unsafeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_STREAM", + "safeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_STREAM" }, "pascalCase": { - "unsafeName": "StreamProtocolWithFlatSchema", - "safeName": "StreamProtocolWithFlatSchema" + "unsafeName": "StreamXFernStreamingNullableConditionStream", + "safeName": "StreamXFernStreamingNullableConditionStream" } }, "fernFilepath": { @@ -6701,17 +16320,110 @@ }, "location": { "method": "POST", - "path": "/stream/protocol-with-flat-schema" + "path": "/stream/x-fern-streaming-nullable-condition" }, "request": { - "type": "body", + "type": "inlined", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingNullableConditionStreamRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingNullableConditionStreamRequest", + "safeName": "streamXFernStreamingNullableConditionStreamRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_nullable_condition_stream_request", + "safeName": "stream_x_fern_streaming_nullable_condition_stream_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_STREAM_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_STREAM_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingNullableConditionStreamRequest", + "safeName": "StreamXFernStreamingNullableConditionStreamRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, "pathParameters": [], + "queryParameters": [], + "headers": [], "body": { - "type": "typeReference", - "value": { - "type": "named", - "value": "type_:StreamRequest" - } + "type": "properties", + "value": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": true + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } }, "response": { @@ -6719,26 +16431,26 @@ }, "examples": null }, - "endpoint_.streamDataContextWithEnvelopeSchema": { + "endpoint_.streamXFernStreamingNullableCondition": { "auth": null, "declaration": { "name": { - "originalName": "streamDataContextWithEnvelopeSchema", + "originalName": "streamXFernStreamingNullableCondition", "camelCase": { - "unsafeName": "streamDataContextWithEnvelopeSchema", - "safeName": "streamDataContextWithEnvelopeSchema" + "unsafeName": "streamXFernStreamingNullableCondition", + "safeName": "streamXFernStreamingNullableCondition" }, "snakeCase": { - "unsafeName": "stream_data_context_with_envelope_schema", - "safeName": "stream_data_context_with_envelope_schema" + "unsafeName": "stream_x_fern_streaming_nullable_condition", + "safeName": "stream_x_fern_streaming_nullable_condition" }, "screamingSnakeCase": { - "unsafeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA", - "safeName": "STREAM_DATA_CONTEXT_WITH_ENVELOPE_SCHEMA" + "unsafeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION", + "safeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION" }, "pascalCase": { - "unsafeName": "StreamDataContextWithEnvelopeSchema", - "safeName": "StreamDataContextWithEnvelopeSchema" + "unsafeName": "StreamXFernStreamingNullableCondition", + "safeName": "StreamXFernStreamingNullableCondition" } }, "fernFilepath": { @@ -6749,44 +16461,137 @@ }, "location": { "method": "POST", - "path": "/stream/data-context-with-envelope-schema" + "path": "/stream/x-fern-streaming-nullable-condition" }, "request": { - "type": "body", + "type": "inlined", + "declaration": { + "name": { + "originalName": "StreamXFernStreamingNullableConditionRequest", + "camelCase": { + "unsafeName": "streamXFernStreamingNullableConditionRequest", + "safeName": "streamXFernStreamingNullableConditionRequest" + }, + "snakeCase": { + "unsafeName": "stream_x_fern_streaming_nullable_condition_request", + "safeName": "stream_x_fern_streaming_nullable_condition_request" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_REQUEST", + "safeName": "STREAM_X_FERN_STREAMING_NULLABLE_CONDITION_REQUEST" + }, + "pascalCase": { + "unsafeName": "StreamXFernStreamingNullableConditionRequest", + "safeName": "StreamXFernStreamingNullableConditionRequest" + } + }, + "fernFilepath": { + "allParts": [], + "packagePath": [], + "file": null + } + }, "pathParameters": [], + "queryParameters": [], + "headers": [], "body": { - "type": "typeReference", - "value": { - "type": "named", - "value": "type_:StreamRequest" - } + "type": "properties", + "value": [ + { + "name": { + "wireValue": "query", + "name": { + "originalName": "query", + "camelCase": { + "unsafeName": "query", + "safeName": "query" + }, + "snakeCase": { + "unsafeName": "query", + "safeName": "query" + }, + "screamingSnakeCase": { + "unsafeName": "QUERY", + "safeName": "QUERY" + }, + "pascalCase": { + "unsafeName": "Query", + "safeName": "Query" + } + } + }, + "typeReference": { + "type": "primitive", + "value": "STRING" + }, + "propertyAccess": null, + "variable": null + }, + { + "name": { + "wireValue": "stream", + "name": { + "originalName": "stream", + "camelCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "snakeCase": { + "unsafeName": "stream", + "safeName": "stream" + }, + "screamingSnakeCase": { + "unsafeName": "STREAM", + "safeName": "STREAM" + }, + "pascalCase": { + "unsafeName": "Stream", + "safeName": "Stream" + } + } + }, + "typeReference": { + "type": "literal", + "value": { + "type": "boolean", + "value": false + } + }, + "propertyAccess": null, + "variable": null + } + ] + }, + "metadata": { + "includePathParameters": false, + "onlyPathParameters": false } }, "response": { - "type": "streaming" + "type": "json" }, "examples": null }, - "endpoint_.streamOasSpecNative": { + "endpoint_.streamXFernStreamingSseOnly": { "auth": null, "declaration": { "name": { - "originalName": "streamOasSpecNative", + "originalName": "streamXFernStreamingSseOnly", "camelCase": { - "unsafeName": "streamOasSpecNative", - "safeName": "streamOasSpecNative" + "unsafeName": "streamXFernStreamingSseOnly", + "safeName": "streamXFernStreamingSseOnly" }, "snakeCase": { - "unsafeName": "stream_oas_spec_native", - "safeName": "stream_oas_spec_native" + "unsafeName": "stream_x_fern_streaming_sse_only", + "safeName": "stream_x_fern_streaming_sse_only" }, "screamingSnakeCase": { - "unsafeName": "STREAM_OAS_SPEC_NATIVE", - "safeName": "STREAM_OAS_SPEC_NATIVE" + "unsafeName": "STREAM_X_FERN_STREAMING_SSE_ONLY", + "safeName": "STREAM_X_FERN_STREAMING_SSE_ONLY" }, "pascalCase": { - "unsafeName": "StreamOasSpecNative", - "safeName": "StreamOasSpecNative" + "unsafeName": "StreamXFernStreamingSseOnly", + "safeName": "StreamXFernStreamingSseOnly" } }, "fernFilepath": { @@ -6797,7 +16602,7 @@ }, "location": { "method": "POST", - "path": "/stream/oas-spec-native" + "path": "/stream/x-fern-streaming-sse-only" }, "request": { "type": "body", @@ -6845,6 +16650,9 @@ "type_:StreamNoContextResponse", "type_:StreamProtocolWithFlatSchemaResponse", "type_:StreamDataContextWithEnvelopeSchemaResponse", + "type_:StreamXFernStreamingUnionStreamRequest", + "type_:StreamXFernStreamingUnionRequest", + "type_:ValidateUnionRequestResponse", "type_:StreamRequest", "type_:Event", "type_:StatusPayload", @@ -6858,7 +16666,17 @@ "type_:ProtocolObjectEvent", "type_:ProtocolCollisionObjectEvent", "type_:DataContextHeartbeat", - "type_:DataContextEntityEvent" + "type_:DataContextEntityEvent", + "type_:CompletionRequest", + "type_:NullableStreamRequest", + "type_:CompletionFullResponseFinishReason", + "type_:CompletionFullResponse", + "type_:CompletionStreamChunk", + "type_:UnionStreamRequestBase", + "type_:UnionStreamMessageVariant", + "type_:UnionStreamInterruptVariant", + "type_:UnionStreamCompactVariant", + "type_:UnionStreamRequest" ], "errors": [], "subpackages": [], diff --git a/packages/commons/mock-utils/index.ts b/packages/commons/mock-utils/index.ts index 7c88bd036a0..0a215a26b05 100644 --- a/packages/commons/mock-utils/index.ts +++ b/packages/commons/mock-utils/index.ts @@ -71,12 +71,17 @@ export class WireMock { } // Determine which URL paths have both SSE and non-SSE endpoints (need body pattern matching) - const pathsNeedingBodyPatterns = new Set(); + // Also extract the stream condition property name from the SSE endpoint's example request body + const pathsNeedingBodyPatterns = new Map(); for (const [key, endpoints] of endpointsByPathAndMethod) { const hasSse = endpoints.some((e) => e.isSse); const hasNonSse = endpoints.some((e) => !e.isSse); if (hasSse && hasNonSse) { - pathsNeedingBodyPatterns.add(key); + const sseEndpoint = endpoints.find((e) => e.isSse); + const streamConditionProperty = sseEndpoint + ? this.findStreamConditionProperty(sseEndpoint.endpoint) + : undefined; + pathsNeedingBodyPatterns.set(key, streamConditionProperty ?? "stream"); } } @@ -95,8 +100,14 @@ export class WireMock { const example = exampleWrapper.example; const urlPath = this.buildUrlPathTemplate(endpoint); const key = `${endpoint.method}:${urlPath}`; - const needsBodyPattern = pathsNeedingBodyPatterns.has(key); - const mapping = this.convertExampleToMapping(ir, service, endpoint, example, needsBodyPattern); + const streamConditionProperty = pathsNeedingBodyPatterns.get(key); + const mapping = this.convertExampleToMapping( + ir, + service, + endpoint, + example, + streamConditionProperty + ); if (mapping) { mappings.push(mapping); } @@ -149,7 +160,7 @@ export class WireMock { service: FernIr.HttpService, endpoint: FernIr.HttpEndpoint, example: FernIr.ExampleEndpointCall | undefined, - needsBodyPattern: boolean + streamConditionProperty: string | undefined ): WireMockMapping | null { // Build URL path template const urlPathTemplate = this.buildUrlPathTemplate(endpoint); @@ -264,7 +275,7 @@ export class WireMock { // Only add body patterns when there are both SSE and non-SSE endpoints for the same URL path // This allows WireMock to differentiate between streaming and non-streaming requests - const shouldAddBodyPattern = needsBodyPattern && isSseResponse; + const shouldAddBodyPattern = streamConditionProperty != null && isSseResponse; // Build auth header matchers for endpoints that require authentication. const authHeaders: Record = {}; @@ -313,8 +324,10 @@ export class WireMock { queryParameters: Object.keys(queryParameters).length > 0 ? queryParameters : undefined, formParameters: {}, // For SSE endpoints that share a URL path with non-SSE endpoints, - // add body pattern to match stream: true - bodyPatterns: shouldAddBodyPattern ? [{ matchesJsonPath: "$[?(@.stream == true)]" }] : undefined + // add body pattern to match the stream condition property + bodyPatterns: shouldAddBodyPattern + ? [{ matchesJsonPath: `$[?(@.${streamConditionProperty} == true)]` }] + : undefined }, response: { status, @@ -408,6 +421,36 @@ export class WireMock { } } + private findStreamConditionProperty(endpoint: FernIr.HttpEndpoint): string | undefined { + const exampleWrapper = endpoint.userSpecifiedExamples[0] ?? endpoint.autogeneratedExamples[0]; + const example = exampleWrapper?.example; + if (example?.request?.type === "inlinedRequestBody") { + // Look for a boolean property set to true in the request body + for (const prop of example.request.properties) { + if (prop.value.jsonExample === true) { + const wireValue = typeof prop.name === "string" ? prop.name : prop.name?.wireValue; + if (wireValue) { + return wireValue; + } + } + } + } + // Fall back to checking jsonExample at the top level + if ( + example?.request?.type === "reference" && + typeof example.request.jsonExample === "object" && + example.request.jsonExample !== null + ) { + const json = example.request.jsonExample as Record; + for (const [key, value] of Object.entries(json)) { + if (value === true) { + return key; + } + } + } + return undefined; + } + private extractExampleValue( exampleValue: FernIr.ExampleTypeReference ): FernIr.ExamplePrimitive | Date | string | number | boolean | Record | null { diff --git a/scripts/debug-sse-pipeline.ts b/scripts/debug-sse-pipeline.ts new file mode 100644 index 00000000000..e1aab08f9d7 --- /dev/null +++ b/scripts/debug-sse-pipeline.ts @@ -0,0 +1,74 @@ +import { execSync } from "child_process"; +import { cpSync, existsSync, mkdirSync } from "fs"; +import { join, resolve } from "path"; + +const ROOT = resolve(__dirname, ".."); +const TEST_DEFS = join(ROOT, "test-definitions"); +const CLI = join(ROOT, "packages/cli/cli/dist/prod/cli.cjs"); +const RESULTS = join(ROOT, ".local/results"); +const API = "server-sent-events-openapi"; + +function fern(args: string): void { + const cmd = `FERN_NO_VERSION_REDIRECTION=true node --enable-source-maps ${CLI} ${args}`; + execSync(cmd, { cwd: TEST_DEFS, stdio: "inherit" }); +} + +function main(): void { + if (!existsSync(CLI)) { + process.stderr.write(`CLI not built. Run: pnpm fern:build\n`); + process.exit(1); + } + + mkdirSync(RESULTS, { recursive: true }); + + const steps: Array<{ name: string; run: () => void }> = [ + { + name: "openapi-ir", + run: () => fern(`openapi-ir ${RESULTS}/openapi-ir.json --api ${API}`) + }, + { + name: "write-definition", + run: () => { + fern(`write-definition --api ${API}`); + const defSrc = join(TEST_DEFS, `fern/apis/${API}/.definition`); + const defDst = join(RESULTS, ".definition"); + if (existsSync(defSrc)) { + cpSync(defSrc, defDst, { recursive: true }); + } else { + process.stderr.write(`Warning: ${defSrc} not found after write-definition\n`); + } + } + }, + { + name: "ir", + run: () => fern(`ir ${RESULTS}/ir.json --api ${API}`) + } + ]; + + const results: Array<{ name: string; ok: boolean }> = []; + + for (const step of steps) { + process.stdout.write(`\n--- ${step.name} ---\n`); + try { + step.run(); + process.stdout.write(`OK: ${step.name}\n`); + results.push({ name: step.name, ok: true }); + } catch { + process.stderr.write(`FAIL: ${step.name}\n`); + results.push({ name: step.name, ok: false }); + } + } + + process.stdout.write(`\n--- summary ---\n`); + for (const r of results) { + process.stdout.write(` ${r.ok ? "OK" : "FAIL"}: ${r.name}\n`); + } + process.stdout.write(`Results in ${RESULTS}/\n`); + + const failed = results.filter((r) => !r.ok); + if (failed.length > 0) { + process.exit(1); + } +} + +main(); diff --git a/seed/go-sdk/seed.yml b/seed/go-sdk/seed.yml index a35aebc5c12..41c3b86ea70 100644 --- a/seed/go-sdk/seed.yml +++ b/seed/go-sdk/seed.yml @@ -346,6 +346,7 @@ allowedFailures: - streaming-parameter - server-sent-event-examples:with-wire-tests # TODO: update wiretests geranation then remove it - server-sent-events:with-wire-tests # TODO: update wiretests geranation then remove it + - server-sent-events-openapi:with-wire-tests # TODO: fix go wire test generation for augmented fixture - server-url-templating - trace - property-access diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/reference.md b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/reference.md index 24c6ef2ceae..517d04d6807 100644 --- a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/reference.md +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/reference.md @@ -482,3 +482,873 @@ client.stream_oas_spec_native() +
client.stream_x_fern_streaming_condition_stream(...) -> typing.Iterator[bytes] +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.stream_x_fern_streaming_condition_stream( + query="query", +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**query:** `str` — The prompt or query to complete. + +
+
+ +
+
+ +**stream:** `typing.Literal` — Whether to stream the response. + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.stream_x_fern_streaming_condition(...) -> CompletionFullResponse +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.stream_x_fern_streaming_condition_stream( + query="query", +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**query:** `str` — The prompt or query to complete. + +
+
+ +
+
+ +**stream:** `typing.Literal` — Whether to stream the response. + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.stream_x_fern_streaming_shared_schema_stream(...) -> typing.Iterator[bytes] +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.stream_x_fern_streaming_shared_schema_stream( + prompt="prompt", + model="model", +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**prompt:** `str` — The prompt to complete. + +
+
+ +
+
+ +**model:** `str` — The model to use. + +
+
+ +
+
+ +**stream:** `typing.Literal` — Whether to stream the response. + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.stream_x_fern_streaming_shared_schema(...) -> CompletionFullResponse +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.stream_x_fern_streaming_shared_schema_stream( + prompt="prompt", + model="model", +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**prompt:** `str` — The prompt to complete. + +
+
+ +
+
+ +**model:** `str` — The model to use. + +
+
+ +
+
+ +**stream:** `typing.Literal` — Whether to stream the response. + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.validate_completion(...) -> CompletionFullResponse +
+
+ +#### 📝 Description + +
+
+ +
+
+ +A non-streaming endpoint that references the same SharedCompletionRequest schema as endpoint 10. Ensures the shared $ref schema remains available and is not excluded during the streaming endpoint's processing. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.validate_completion( + prompt="prompt", + model="model", +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**prompt:** `str` — The prompt to complete. + +
+
+ +
+
+ +**model:** `str` — The model to use. + +
+
+ +
+
+ +**stream:** `typing.Optional[bool]` — Whether to stream the response. + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.stream_x_fern_streaming_union_stream(...) -> typing.Iterator[bytes] +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi, StreamXFernStreamingUnionStreamRequest_Message + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.stream_x_fern_streaming_union_stream( + request=StreamXFernStreamingUnionStreamRequest_Message( + stream_response=True, + prompt="prompt", + message="message", + ), +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**request:** `StreamXFernStreamingUnionStreamRequest` — A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.stream_x_fern_streaming_union(...) -> CompletionFullResponse +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi, StreamXFernStreamingUnionStreamRequest_Message + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.stream_x_fern_streaming_union_stream( + request=StreamXFernStreamingUnionStreamRequest_Message( + stream_response=False, + prompt="prompt", + message="message", + ), +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**request:** `StreamXFernStreamingUnionRequest` — A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.validate_union_request(...) -> ValidateUnionRequestResponse +
+
+ +#### 📝 Description + +
+
+ +
+
+ +References UnionStreamRequestBase directly, ensuring the base schema cannot be excluded from the context. This endpoint exists to verify that shared base schemas used in discriminated union variants with stream-condition remain available. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.validate_union_request( + prompt="prompt", +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**request:** `UnionStreamRequestBase` + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.stream_x_fern_streaming_nullable_condition_stream(...) -> typing.Iterator[bytes] +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.stream_x_fern_streaming_nullable_condition_stream( + query="query", +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**query:** `str` — The prompt or query to complete. + +
+
+ +
+
+ +**stream:** `typing.Literal` — Whether to stream the response. This field is nullable (OAS 3.1 type array), which previously caused the const literal to be overwritten by the nullable type during spread in the importer. + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.stream_x_fern_streaming_nullable_condition(...) -> CompletionFullResponse +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.stream_x_fern_streaming_nullable_condition_stream( + query="query", +) + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**query:** `str` — The prompt or query to complete. + +
+
+ +
+
+ +**stream:** `typing.Literal` — Whether to stream the response. This field is nullable (OAS 3.1 type array), which previously caused the const literal to be overwritten by the nullable type during spread in the importer. + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ +
client.stream_x_fern_streaming_sse_only(...) -> typing.Iterator[bytes] +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Uses x-fern-streaming with format: sse but no stream-condition. This represents a stream-only endpoint that always returns SSE. There is no non-streaming variant, and the response is always a stream of chunks. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```python +from seed import SeedApi + +client = SeedApi( + base_url="https://yourhost.com/path/to/api", +) + +client.stream_x_fern_streaming_sse_only() + +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**request:** `StreamRequest` + +
+
+ +
+
+ +**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration. + +
+
+
+
+ + +
+
+
+ diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/snippet.json b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/snippet.json index e144c2cbdce..916cb302aef 100644 --- a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/snippet.json +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/snippet.json @@ -91,6 +91,149 @@ "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n response = await client.stream_oas_spec_native()\n async for chunk in response.data:\n yield chunk\n\n\nasyncio.run(main())\n", "type": "python" } + }, + { + "example_identifier": "default", + "id": { + "path": "/stream/x-fern-streaming-condition", + "method": "POST", + "identifier_override": "endpoint_.streamXFernStreamingCondition_stream" + }, + "snippet": { + "sync_client": "from seed import SeedApi\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nresponse = client.stream_x_fern_streaming_condition_stream(\n query=\"query\",\n)\nfor chunk in response.data:\n yield chunk\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n response = await client.stream_x_fern_streaming_condition_stream(\n query=\"query\",\n )\n async for chunk in response.data:\n yield chunk\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/stream/x-fern-streaming-condition", + "method": "POST", + "identifier_override": "endpoint_.streamXFernStreamingCondition" + }, + "snippet": { + "sync_client": "from seed import SeedApi\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nclient.stream_x_fern_streaming_condition(\n query=\"query\",\n)\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n await client.stream_x_fern_streaming_condition(\n query=\"query\",\n )\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/stream/x-fern-streaming-shared-schema", + "method": "POST", + "identifier_override": "endpoint_.streamXFernStreamingSharedSchema_stream" + }, + "snippet": { + "sync_client": "from seed import SeedApi\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nresponse = client.stream_x_fern_streaming_shared_schema_stream(\n prompt=\"prompt\",\n model=\"model\",\n)\nfor chunk in response.data:\n yield chunk\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n response = await client.stream_x_fern_streaming_shared_schema_stream(\n prompt=\"prompt\",\n model=\"model\",\n )\n async for chunk in response.data:\n yield chunk\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/stream/x-fern-streaming-shared-schema", + "method": "POST", + "identifier_override": "endpoint_.streamXFernStreamingSharedSchema" + }, + "snippet": { + "sync_client": "from seed import SeedApi\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nclient.stream_x_fern_streaming_shared_schema(\n prompt=\"prompt\",\n model=\"model\",\n)\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n await client.stream_x_fern_streaming_shared_schema(\n prompt=\"prompt\",\n model=\"model\",\n )\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/validate-completion", + "method": "POST", + "identifier_override": "endpoint_.validateCompletion" + }, + "snippet": { + "sync_client": "from seed import SeedApi\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nclient.validate_completion(\n prompt=\"prompt\",\n model=\"model\",\n)\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n await client.validate_completion(\n prompt=\"prompt\",\n model=\"model\",\n )\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/stream/x-fern-streaming-union", + "method": "POST", + "identifier_override": "endpoint_.streamXFernStreamingUnion_stream" + }, + "snippet": { + "sync_client": "from seed import SeedApi, StreamXFernStreamingUnionStreamRequest_Message\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nresponse = client.stream_x_fern_streaming_union_stream(\n request=StreamXFernStreamingUnionStreamRequest_Message(\n prompt=\"prompt\",\n message=\"message\",\n stream_response=True,\n ),\n)\nfor chunk in response.data:\n yield chunk\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi, StreamXFernStreamingUnionStreamRequest_Message\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n response = await client.stream_x_fern_streaming_union_stream(\n request=StreamXFernStreamingUnionStreamRequest_Message(\n prompt=\"prompt\",\n message=\"message\",\n stream_response=True,\n ),\n )\n async for chunk in response.data:\n yield chunk\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/stream/x-fern-streaming-union", + "method": "POST", + "identifier_override": "endpoint_.streamXFernStreamingUnion" + }, + "snippet": { + "sync_client": "from seed import SeedApi, StreamXFernStreamingUnionRequest_Message\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nclient.stream_x_fern_streaming_union(\n request=StreamXFernStreamingUnionRequest_Message(\n prompt=\"prompt\",\n message=\"message\",\n stream_response=False,\n ),\n)\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi, StreamXFernStreamingUnionRequest_Message\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n await client.stream_x_fern_streaming_union(\n request=StreamXFernStreamingUnionRequest_Message(\n prompt=\"prompt\",\n message=\"message\",\n stream_response=False,\n ),\n )\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/validate-union-request", + "method": "POST", + "identifier_override": "endpoint_.validateUnionRequest" + }, + "snippet": { + "sync_client": "from seed import SeedApi\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nclient.validate_union_request(\n prompt=\"prompt\",\n)\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n await client.validate_union_request(\n prompt=\"prompt\",\n )\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/stream/x-fern-streaming-nullable-condition", + "method": "POST", + "identifier_override": "endpoint_.streamXFernStreamingNullableCondition_stream" + }, + "snippet": { + "sync_client": "from seed import SeedApi\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nresponse = client.stream_x_fern_streaming_nullable_condition_stream(\n query=\"query\",\n)\nfor chunk in response.data:\n yield chunk\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n response = await client.stream_x_fern_streaming_nullable_condition_stream(\n query=\"query\",\n )\n async for chunk in response.data:\n yield chunk\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/stream/x-fern-streaming-nullable-condition", + "method": "POST", + "identifier_override": "endpoint_.streamXFernStreamingNullableCondition" + }, + "snippet": { + "sync_client": "from seed import SeedApi\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nclient.stream_x_fern_streaming_nullable_condition(\n query=\"query\",\n)\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n await client.stream_x_fern_streaming_nullable_condition(\n query=\"query\",\n )\n\n\nasyncio.run(main())\n", + "type": "python" + } + }, + { + "example_identifier": "default", + "id": { + "path": "/stream/x-fern-streaming-sse-only", + "method": "POST", + "identifier_override": "endpoint_.streamXFernStreamingSseOnly" + }, + "snippet": { + "sync_client": "from seed import SeedApi\n\nclient = SeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\nresponse = client.stream_x_fern_streaming_sse_only()\nfor chunk in response.data:\n yield chunk\n", + "async_client": "import asyncio\n\nfrom seed import AsyncSeedApi\n\nclient = AsyncSeedApi(\n base_url=\"https://yourhost.com/path/to/api\",\n)\n\n\nasync def main() -> None:\n response = await client.stream_x_fern_streaming_sse_only()\n async for chunk in response.data:\n yield chunk\n\n\nasyncio.run(main())\n", + "type": "python" + } } ] } \ No newline at end of file diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/__init__.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/__init__.py index de64565fcd8..4202771ecfa 100644 --- a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/__init__.py +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/__init__.py @@ -7,12 +7,17 @@ if typing.TYPE_CHECKING: from .types import ( + CompletionFullResponse, + CompletionFullResponseFinishReason, + CompletionRequest, + CompletionStreamChunk, DataContextEntityEvent, DataContextHeartbeat, EntityEventPayload, EntityEventPayloadEventType, Event, HeartbeatPayload, + NullableStreamRequest, ObjectPayloadWithEventField, ProtocolCollisionObjectEvent, ProtocolHeartbeat, @@ -45,12 +50,33 @@ StreamProtocolWithFlatSchemaResponse_Entity, StreamProtocolWithFlatSchemaResponse_Heartbeat, StreamRequest, + StreamXFernStreamingUnionRequest, + StreamXFernStreamingUnionRequest_Compact, + StreamXFernStreamingUnionRequest_Interrupt, + StreamXFernStreamingUnionRequest_Message, + StreamXFernStreamingUnionStreamRequest, + StreamXFernStreamingUnionStreamRequest_Compact, + StreamXFernStreamingUnionStreamRequest_Interrupt, + StreamXFernStreamingUnionStreamRequest_Message, + UnionStreamCompactVariant, + UnionStreamInterruptVariant, + UnionStreamMessageVariant, + UnionStreamRequest, + UnionStreamRequestBase, + UnionStreamRequest_Compact, + UnionStreamRequest_Interrupt, + UnionStreamRequest_Message, + ValidateUnionRequestResponse, ) from ._default_clients import DefaultAioHttpClient, DefaultAsyncHttpxClient from .client import AsyncSeedApi, SeedApi from .version import __version__ _dynamic_imports: typing.Dict[str, str] = { "AsyncSeedApi": ".client", + "CompletionFullResponse": ".types", + "CompletionFullResponseFinishReason": ".types", + "CompletionRequest": ".types", + "CompletionStreamChunk": ".types", "DataContextEntityEvent": ".types", "DataContextHeartbeat": ".types", "DefaultAioHttpClient": "._default_clients", @@ -59,6 +85,7 @@ "EntityEventPayloadEventType": ".types", "Event": ".types", "HeartbeatPayload": ".types", + "NullableStreamRequest": ".types", "ObjectPayloadWithEventField": ".types", "ProtocolCollisionObjectEvent": ".types", "ProtocolHeartbeat": ".types", @@ -92,6 +119,23 @@ "StreamProtocolWithFlatSchemaResponse_Entity": ".types", "StreamProtocolWithFlatSchemaResponse_Heartbeat": ".types", "StreamRequest": ".types", + "StreamXFernStreamingUnionRequest": ".types", + "StreamXFernStreamingUnionRequest_Compact": ".types", + "StreamXFernStreamingUnionRequest_Interrupt": ".types", + "StreamXFernStreamingUnionRequest_Message": ".types", + "StreamXFernStreamingUnionStreamRequest": ".types", + "StreamXFernStreamingUnionStreamRequest_Compact": ".types", + "StreamXFernStreamingUnionStreamRequest_Interrupt": ".types", + "StreamXFernStreamingUnionStreamRequest_Message": ".types", + "UnionStreamCompactVariant": ".types", + "UnionStreamInterruptVariant": ".types", + "UnionStreamMessageVariant": ".types", + "UnionStreamRequest": ".types", + "UnionStreamRequestBase": ".types", + "UnionStreamRequest_Compact": ".types", + "UnionStreamRequest_Interrupt": ".types", + "UnionStreamRequest_Message": ".types", + "ValidateUnionRequestResponse": ".types", "__version__": ".version", } @@ -119,6 +163,10 @@ def __dir__(): __all__ = [ "AsyncSeedApi", + "CompletionFullResponse", + "CompletionFullResponseFinishReason", + "CompletionRequest", + "CompletionStreamChunk", "DataContextEntityEvent", "DataContextHeartbeat", "DefaultAioHttpClient", @@ -127,6 +175,7 @@ def __dir__(): "EntityEventPayloadEventType", "Event", "HeartbeatPayload", + "NullableStreamRequest", "ObjectPayloadWithEventField", "ProtocolCollisionObjectEvent", "ProtocolHeartbeat", @@ -160,5 +209,22 @@ def __dir__(): "StreamProtocolWithFlatSchemaResponse_Entity", "StreamProtocolWithFlatSchemaResponse_Heartbeat", "StreamRequest", + "StreamXFernStreamingUnionRequest", + "StreamXFernStreamingUnionRequest_Compact", + "StreamXFernStreamingUnionRequest_Interrupt", + "StreamXFernStreamingUnionRequest_Message", + "StreamXFernStreamingUnionStreamRequest", + "StreamXFernStreamingUnionStreamRequest_Compact", + "StreamXFernStreamingUnionStreamRequest_Interrupt", + "StreamXFernStreamingUnionStreamRequest_Message", + "UnionStreamCompactVariant", + "UnionStreamInterruptVariant", + "UnionStreamMessageVariant", + "UnionStreamRequest", + "UnionStreamRequestBase", + "UnionStreamRequest_Compact", + "UnionStreamRequest_Interrupt", + "UnionStreamRequest_Message", + "ValidateUnionRequestResponse", "__version__", ] diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/client.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/client.py index 2682796eeeb..692e5ce31ae 100644 --- a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/client.py +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/client.py @@ -7,6 +7,8 @@ from .core.logging import LogConfig, Logger from .core.request_options import RequestOptions from .raw_client import AsyncRawSeedApi, RawSeedApi +from .types.completion_full_response import CompletionFullResponse +from .types.completion_stream_chunk import CompletionStreamChunk from .types.event import Event from .types.stream_data_context_response import StreamDataContextResponse from .types.stream_data_context_with_envelope_schema_response import StreamDataContextWithEnvelopeSchemaResponse @@ -14,6 +16,9 @@ from .types.stream_protocol_collision_response import StreamProtocolCollisionResponse from .types.stream_protocol_no_collision_response import StreamProtocolNoCollisionResponse from .types.stream_protocol_with_flat_schema_response import StreamProtocolWithFlatSchemaResponse +from .types.stream_x_fern_streaming_union_request import StreamXFernStreamingUnionRequest +from .types.stream_x_fern_streaming_union_stream_request import StreamXFernStreamingUnionStreamRequest +from .types.validate_union_request_response import ValidateUnionRequestResponse # this is used as the default value for optional parameters OMIT = typing.cast(typing.Any, ...) @@ -315,6 +320,428 @@ def stream_oas_spec_native( with self._raw_client.stream_oas_spec_native(query=query, request_options=request_options) as r: yield from r.data + def stream_x_fern_streaming_condition_stream( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.Iterator[CompletionStreamChunk]: + """ + Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[CompletionStreamChunk] + + + Examples + -------- + from seed import SeedApi + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + response = client.stream_x_fern_streaming_condition_stream( + query="query", + ) + for chunk in response: + yield chunk + """ + with self._raw_client.stream_x_fern_streaming_condition_stream( + query=query, request_options=request_options + ) as r: + yield from r.data + + def stream_x_fern_streaming_condition( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> CompletionFullResponse: + """ + Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + CompletionFullResponse + + + Examples + -------- + from seed import SeedApi + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + client.stream_x_fern_streaming_condition( + query="query", + ) + """ + _response = self._raw_client.stream_x_fern_streaming_condition(query=query, request_options=request_options) + return _response.data + + def stream_x_fern_streaming_shared_schema_stream( + self, *, prompt: str, model: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.Iterator[CompletionStreamChunk]: + """ + Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. + + Parameters + ---------- + prompt : str + The prompt to complete. + + model : str + The model to use. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[CompletionStreamChunk] + + + Examples + -------- + from seed import SeedApi + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + response = client.stream_x_fern_streaming_shared_schema_stream( + prompt="prompt", + model="model", + ) + for chunk in response: + yield chunk + """ + with self._raw_client.stream_x_fern_streaming_shared_schema_stream( + prompt=prompt, model=model, request_options=request_options + ) as r: + yield from r.data + + def stream_x_fern_streaming_shared_schema( + self, *, prompt: str, model: str, request_options: typing.Optional[RequestOptions] = None + ) -> CompletionFullResponse: + """ + Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. + + Parameters + ---------- + prompt : str + The prompt to complete. + + model : str + The model to use. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + CompletionFullResponse + + + Examples + -------- + from seed import SeedApi + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + client.stream_x_fern_streaming_shared_schema( + prompt="prompt", + model="model", + ) + """ + _response = self._raw_client.stream_x_fern_streaming_shared_schema( + prompt=prompt, model=model, request_options=request_options + ) + return _response.data + + def validate_completion( + self, + *, + prompt: str, + model: str, + stream: typing.Optional[bool] = OMIT, + request_options: typing.Optional[RequestOptions] = None, + ) -> CompletionFullResponse: + """ + A non-streaming endpoint that references the same SharedCompletionRequest schema as endpoint 10. Ensures the shared $ref schema remains available and is not excluded during the streaming endpoint's processing. + + Parameters + ---------- + prompt : str + The prompt to complete. + + model : str + The model to use. + + stream : typing.Optional[bool] + Whether to stream the response. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + CompletionFullResponse + Validation result + + Examples + -------- + from seed import SeedApi + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + client.validate_completion( + prompt="prompt", + model="model", + ) + """ + _response = self._raw_client.validate_completion( + prompt=prompt, model=model, stream=stream, request_options=request_options + ) + return _response.data + + def stream_x_fern_streaming_union_stream( + self, + *, + request: StreamXFernStreamingUnionStreamRequest, + request_options: typing.Optional[RequestOptions] = None, + ) -> typing.Iterator[CompletionStreamChunk]: + """ + Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. + + Parameters + ---------- + request : StreamXFernStreamingUnionStreamRequest + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[CompletionStreamChunk] + + + Examples + -------- + from seed import SeedApi, StreamXFernStreamingUnionStreamRequest_Message + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + response = client.stream_x_fern_streaming_union_stream( + request=StreamXFernStreamingUnionStreamRequest_Message( + prompt="prompt", + message="message", + stream_response=True, + ), + ) + for chunk in response: + yield chunk + """ + with self._raw_client.stream_x_fern_streaming_union_stream( + request=request, request_options=request_options + ) as r: + yield from r.data + + def stream_x_fern_streaming_union( + self, *, request: StreamXFernStreamingUnionRequest, request_options: typing.Optional[RequestOptions] = None + ) -> CompletionFullResponse: + """ + Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. + + Parameters + ---------- + request : StreamXFernStreamingUnionRequest + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + CompletionFullResponse + + + Examples + -------- + from seed import SeedApi, StreamXFernStreamingUnionRequest_Message + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + client.stream_x_fern_streaming_union( + request=StreamXFernStreamingUnionRequest_Message( + prompt="prompt", + message="message", + stream_response=False, + ), + ) + """ + _response = self._raw_client.stream_x_fern_streaming_union(request=request, request_options=request_options) + return _response.data + + def validate_union_request( + self, + *, + prompt: str, + stream_response: typing.Optional[bool] = OMIT, + request_options: typing.Optional[RequestOptions] = None, + ) -> ValidateUnionRequestResponse: + """ + References UnionStreamRequestBase directly, ensuring the base schema cannot be excluded from the context. This endpoint exists to verify that shared base schemas used in discriminated union variants with stream-condition remain available. + + Parameters + ---------- + prompt : str + The input prompt. + + stream_response : typing.Optional[bool] + Whether to stream the response. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + ValidateUnionRequestResponse + Validation result + + Examples + -------- + from seed import SeedApi + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + client.validate_union_request( + prompt="prompt", + ) + """ + _response = self._raw_client.validate_union_request( + prompt=prompt, stream_response=stream_response, request_options=request_options + ) + return _response.data + + def stream_x_fern_streaming_nullable_condition_stream( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.Iterator[CompletionStreamChunk]: + """ + Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[CompletionStreamChunk] + + + Examples + -------- + from seed import SeedApi + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + response = client.stream_x_fern_streaming_nullable_condition_stream( + query="query", + ) + for chunk in response: + yield chunk + """ + with self._raw_client.stream_x_fern_streaming_nullable_condition_stream( + query=query, request_options=request_options + ) as r: + yield from r.data + + def stream_x_fern_streaming_nullable_condition( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> CompletionFullResponse: + """ + Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + CompletionFullResponse + + + Examples + -------- + from seed import SeedApi + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + client.stream_x_fern_streaming_nullable_condition( + query="query", + ) + """ + _response = self._raw_client.stream_x_fern_streaming_nullable_condition( + query=query, request_options=request_options + ) + return _response.data + + def stream_x_fern_streaming_sse_only( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.Iterator[str]: + """ + Uses x-fern-streaming with format: sse but no stream-condition. This represents a stream-only endpoint that always returns SSE. There is no non-streaming variant, and the response is always a stream of chunks. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[str] + SSE stream of completion chunks + + Examples + -------- + from seed import SeedApi + + client = SeedApi( + base_url="https://yourhost.com/path/to/api", + ) + response = client.stream_x_fern_streaming_sse_only() + for chunk in response: + yield chunk + """ + with self._raw_client.stream_x_fern_streaming_sse_only(query=query, request_options=request_options) as r: + yield from r.data + def _make_default_async_client( timeout: typing.Optional[float], @@ -396,17 +823,265 @@ def with_raw_response(self) -> AsyncRawSeedApi: """ Retrieves a raw implementation of this client that returns raw responses. - Returns - ------- - AsyncRawSeedApi + Returns + ------- + AsyncRawSeedApi + """ + return self._raw_client + + async def stream_protocol_no_collision( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[StreamProtocolNoCollisionResponse]: + """ + Uses discriminator with mapping, x-fern-discriminator-context set to protocol. Because the discriminant is at the protocol level, the data field can be any type or absent entirely. Demonstrates heartbeat (no data), string literal, number literal, and object data payloads. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[StreamProtocolNoCollisionResponse] + SSE stream with protocol-level discrimination and mixed data types + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + response = await client.stream_protocol_no_collision() + async for chunk in response: + yield chunk + + + asyncio.run(main()) + """ + async with self._raw_client.stream_protocol_no_collision(query=query, request_options=request_options) as r: + async for _chunk in r.data: + yield _chunk + + async def stream_protocol_collision( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[StreamProtocolCollisionResponse]: + """ + Same as endpoint 1, but the object data payload contains its own "event" property, which collides with the SSE envelope's "event" discriminator field. Tests whether generators correctly separate the protocol-level discriminant from the data-level field when context=protocol is specified. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[StreamProtocolCollisionResponse] + SSE stream with protocol context and event field collision + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + response = await client.stream_protocol_collision() + async for chunk in response: + yield chunk + + + asyncio.run(main()) + """ + async with self._raw_client.stream_protocol_collision(query=query, request_options=request_options) as r: + async for _chunk in r.data: + yield _chunk + + async def stream_data_context( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[StreamDataContextResponse]: + """ + x-fern-discriminator-context is explicitly set to "data" (the default value). Each variant uses allOf to extend a payload schema and adds the "event" discriminant property at the same level. There is no "data" wrapper. The discriminant and payload fields coexist in a single flat object. This matches the real-world pattern used by customers with context=data. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[StreamDataContextResponse] + SSE stream with discriminator context set to data + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + response = await client.stream_data_context() + async for chunk in response: + yield chunk + + + asyncio.run(main()) + """ + async with self._raw_client.stream_data_context(query=query, request_options=request_options) as r: + async for _chunk in r.data: + yield _chunk + + async def stream_no_context( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[StreamNoContextResponse]: + """ + The x-fern-discriminator-context extension is omitted entirely. Tests whether Fern correctly infers the default behavior (context=data) when the extension is absent. Same flat allOf pattern as endpoint 3. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[StreamNoContextResponse] + SSE stream with no discriminator context hint + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + response = await client.stream_no_context() + async for chunk in response: + yield chunk + + + asyncio.run(main()) + """ + async with self._raw_client.stream_no_context(query=query, request_options=request_options) as r: + async for _chunk in r.data: + yield _chunk + + async def stream_protocol_with_flat_schema( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse]: + """ + Mismatched combination: context=protocol with the flat allOf schema pattern that is normally used with context=data. Shows what happens when the discriminant is declared as protocol-level but the schema uses allOf to flatten the event field alongside payload fields instead of wrapping them in a data field. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse] + SSE stream with protocol context but flat allOf schemas + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + response = await client.stream_protocol_with_flat_schema() + async for chunk in response: + yield chunk + + + asyncio.run(main()) + """ + async with self._raw_client.stream_protocol_with_flat_schema(query=query, request_options=request_options) as r: + async for _chunk in r.data: + yield _chunk + + async def stream_data_context_with_envelope_schema( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse]: + """ + Mismatched combination: context=data with the envelope+data schema pattern that is normally used with context=protocol. Shows what happens when the discriminant is declared as data-level but the schema separates the event field and data field into an envelope structure. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse] + SSE stream with data context but envelope+data schemas + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + response = await client.stream_data_context_with_envelope_schema() + async for chunk in response: + yield chunk + + + asyncio.run(main()) """ - return self._raw_client + async with self._raw_client.stream_data_context_with_envelope_schema( + query=query, request_options=request_options + ) as r: + async for _chunk in r.data: + yield _chunk - async def stream_protocol_no_collision( + async def stream_oas_spec_native( self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[StreamProtocolNoCollisionResponse]: + ) -> typing.AsyncIterator[Event]: """ - Uses discriminator with mapping, x-fern-discriminator-context set to protocol. Because the discriminant is at the protocol level, the data field can be any type or absent entirely. Demonstrates heartbeat (no data), string literal, number literal, and object data payloads. + Follows the pattern from the OAS 3.2 specification's own SSE example. The itemSchema extends a base Event schema via $ref and uses inline oneOf variants with const on the event field to distinguish event types. Data fields use contentSchema/contentMediaType for structured payloads. No discriminator object is used. Event type resolution relies on const matching. Parameters ---------- @@ -417,8 +1092,8 @@ async def stream_protocol_no_collision( Yields ------ - typing.AsyncIterator[StreamProtocolNoCollisionResponse] - SSE stream with protocol-level discrimination and mixed data types + typing.AsyncIterator[Event] + SSE stream following the OAS 3.2 spec example pattern Examples -------- @@ -432,34 +1107,35 @@ async def stream_protocol_no_collision( async def main() -> None: - response = await client.stream_protocol_no_collision() + response = await client.stream_oas_spec_native() async for chunk in response: yield chunk asyncio.run(main()) """ - async with self._raw_client.stream_protocol_no_collision(query=query, request_options=request_options) as r: + async with self._raw_client.stream_oas_spec_native(query=query, request_options=request_options) as r: async for _chunk in r.data: yield _chunk - async def stream_protocol_collision( - self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[StreamProtocolCollisionResponse]: + async def stream_x_fern_streaming_condition_stream( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[CompletionStreamChunk]: """ - Same as endpoint 1, but the object data payload contains its own "event" property, which collides with the SSE envelope's "event" discriminator field. Tests whether generators correctly separate the protocol-level discriminant from the data-level field when context=protocol is specified. + Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. Parameters ---------- - query : typing.Optional[str] + query : str + The prompt or query to complete. request_options : typing.Optional[RequestOptions] Request-specific configuration. Yields ------ - typing.AsyncIterator[StreamProtocolCollisionResponse] - SSE stream with protocol context and event field collision + typing.AsyncIterator[CompletionStreamChunk] + Examples -------- @@ -473,34 +1149,39 @@ async def stream_protocol_collision( async def main() -> None: - response = await client.stream_protocol_collision() + response = await client.stream_x_fern_streaming_condition_stream( + query="query", + ) async for chunk in response: yield chunk asyncio.run(main()) """ - async with self._raw_client.stream_protocol_collision(query=query, request_options=request_options) as r: + async with self._raw_client.stream_x_fern_streaming_condition_stream( + query=query, request_options=request_options + ) as r: async for _chunk in r.data: yield _chunk - async def stream_data_context( - self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[StreamDataContextResponse]: + async def stream_x_fern_streaming_condition( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> CompletionFullResponse: """ - x-fern-discriminator-context is explicitly set to "data" (the default value). Each variant uses allOf to extend a payload schema and adds the "event" discriminant property at the same level. There is no "data" wrapper. The discriminant and payload fields coexist in a single flat object. This matches the real-world pattern used by customers with context=data. + Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. Parameters ---------- - query : typing.Optional[str] + query : str + The prompt or query to complete. request_options : typing.Optional[RequestOptions] Request-specific configuration. - Yields - ------ - typing.AsyncIterator[StreamDataContextResponse] - SSE stream with discriminator context set to data + Returns + ------- + CompletionFullResponse + Examples -------- @@ -514,34 +1195,39 @@ async def stream_data_context( async def main() -> None: - response = await client.stream_data_context() - async for chunk in response: - yield chunk + await client.stream_x_fern_streaming_condition( + query="query", + ) asyncio.run(main()) """ - async with self._raw_client.stream_data_context(query=query, request_options=request_options) as r: - async for _chunk in r.data: - yield _chunk + _response = await self._raw_client.stream_x_fern_streaming_condition( + query=query, request_options=request_options + ) + return _response.data - async def stream_no_context( - self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[StreamNoContextResponse]: + async def stream_x_fern_streaming_shared_schema_stream( + self, *, prompt: str, model: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[CompletionStreamChunk]: """ - The x-fern-discriminator-context extension is omitted entirely. Tests whether Fern correctly infers the default behavior (context=data) when the extension is absent. Same flat allOf pattern as endpoint 3. + Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. Parameters ---------- - query : typing.Optional[str] + prompt : str + The prompt to complete. + + model : str + The model to use. request_options : typing.Optional[RequestOptions] Request-specific configuration. Yields ------ - typing.AsyncIterator[StreamNoContextResponse] - SSE stream with no discriminator context hint + typing.AsyncIterator[CompletionStreamChunk] + Examples -------- @@ -555,40 +1241,150 @@ async def stream_no_context( async def main() -> None: - response = await client.stream_no_context() + response = await client.stream_x_fern_streaming_shared_schema_stream( + prompt="prompt", + model="model", + ) async for chunk in response: yield chunk asyncio.run(main()) """ - async with self._raw_client.stream_no_context(query=query, request_options=request_options) as r: + async with self._raw_client.stream_x_fern_streaming_shared_schema_stream( + prompt=prompt, model=model, request_options=request_options + ) as r: async for _chunk in r.data: yield _chunk - async def stream_protocol_with_flat_schema( - self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse]: + async def stream_x_fern_streaming_shared_schema( + self, *, prompt: str, model: str, request_options: typing.Optional[RequestOptions] = None + ) -> CompletionFullResponse: """ - Mismatched combination: context=protocol with the flat allOf schema pattern that is normally used with context=data. Shows what happens when the discriminant is declared as protocol-level but the schema uses allOf to flatten the event field alongside payload fields instead of wrapping them in a data field. + Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. Parameters ---------- - query : typing.Optional[str] + prompt : str + The prompt to complete. + + model : str + The model to use. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + CompletionFullResponse + + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + await client.stream_x_fern_streaming_shared_schema( + prompt="prompt", + model="model", + ) + + + asyncio.run(main()) + """ + _response = await self._raw_client.stream_x_fern_streaming_shared_schema( + prompt=prompt, model=model, request_options=request_options + ) + return _response.data + + async def validate_completion( + self, + *, + prompt: str, + model: str, + stream: typing.Optional[bool] = OMIT, + request_options: typing.Optional[RequestOptions] = None, + ) -> CompletionFullResponse: + """ + A non-streaming endpoint that references the same SharedCompletionRequest schema as endpoint 10. Ensures the shared $ref schema remains available and is not excluded during the streaming endpoint's processing. + + Parameters + ---------- + prompt : str + The prompt to complete. + + model : str + The model to use. + + stream : typing.Optional[bool] + Whether to stream the response. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + CompletionFullResponse + Validation result + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + await client.validate_completion( + prompt="prompt", + model="model", + ) + + + asyncio.run(main()) + """ + _response = await self._raw_client.validate_completion( + prompt=prompt, model=model, stream=stream, request_options=request_options + ) + return _response.data + + async def stream_x_fern_streaming_union_stream( + self, + *, + request: StreamXFernStreamingUnionStreamRequest, + request_options: typing.Optional[RequestOptions] = None, + ) -> typing.AsyncIterator[CompletionStreamChunk]: + """ + Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. + + Parameters + ---------- + request : StreamXFernStreamingUnionStreamRequest request_options : typing.Optional[RequestOptions] Request-specific configuration. Yields ------ - typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse] - SSE stream with protocol context but flat allOf schemas + typing.AsyncIterator[CompletionStreamChunk] + Examples -------- import asyncio - from seed import AsyncSeedApi + from seed import AsyncSeedApi, StreamXFernStreamingUnionStreamRequest_Message client = AsyncSeedApi( base_url="https://yourhost.com/path/to/api", @@ -596,34 +1392,139 @@ async def stream_protocol_with_flat_schema( async def main() -> None: - response = await client.stream_protocol_with_flat_schema() + response = await client.stream_x_fern_streaming_union_stream( + request=StreamXFernStreamingUnionStreamRequest_Message( + prompt="prompt", + message="message", + stream_response=True, + ), + ) async for chunk in response: yield chunk asyncio.run(main()) """ - async with self._raw_client.stream_protocol_with_flat_schema(query=query, request_options=request_options) as r: + async with self._raw_client.stream_x_fern_streaming_union_stream( + request=request, request_options=request_options + ) as r: async for _chunk in r.data: yield _chunk - async def stream_data_context_with_envelope_schema( - self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse]: + async def stream_x_fern_streaming_union( + self, *, request: StreamXFernStreamingUnionRequest, request_options: typing.Optional[RequestOptions] = None + ) -> CompletionFullResponse: """ - Mismatched combination: context=data with the envelope+data schema pattern that is normally used with context=protocol. Shows what happens when the discriminant is declared as data-level but the schema separates the event field and data field into an envelope structure. + Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. Parameters ---------- - query : typing.Optional[str] + request : StreamXFernStreamingUnionRequest + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + CompletionFullResponse + + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi, StreamXFernStreamingUnionRequest_Message + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + await client.stream_x_fern_streaming_union( + request=StreamXFernStreamingUnionRequest_Message( + prompt="prompt", + message="message", + stream_response=False, + ), + ) + + + asyncio.run(main()) + """ + _response = await self._raw_client.stream_x_fern_streaming_union( + request=request, request_options=request_options + ) + return _response.data + + async def validate_union_request( + self, + *, + prompt: str, + stream_response: typing.Optional[bool] = OMIT, + request_options: typing.Optional[RequestOptions] = None, + ) -> ValidateUnionRequestResponse: + """ + References UnionStreamRequestBase directly, ensuring the base schema cannot be excluded from the context. This endpoint exists to verify that shared base schemas used in discriminated union variants with stream-condition remain available. + + Parameters + ---------- + prompt : str + The input prompt. + + stream_response : typing.Optional[bool] + Whether to stream the response. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + ValidateUnionRequestResponse + Validation result + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + await client.validate_union_request( + prompt="prompt", + ) + + + asyncio.run(main()) + """ + _response = await self._raw_client.validate_union_request( + prompt=prompt, stream_response=stream_response, request_options=request_options + ) + return _response.data + + async def stream_x_fern_streaming_nullable_condition_stream( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[CompletionStreamChunk]: + """ + Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. + + Parameters + ---------- + query : str + The prompt or query to complete. request_options : typing.Optional[RequestOptions] Request-specific configuration. Yields ------ - typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse] - SSE stream with data context but envelope+data schemas + typing.AsyncIterator[CompletionStreamChunk] + Examples -------- @@ -637,24 +1538,69 @@ async def stream_data_context_with_envelope_schema( async def main() -> None: - response = await client.stream_data_context_with_envelope_schema() + response = await client.stream_x_fern_streaming_nullable_condition_stream( + query="query", + ) async for chunk in response: yield chunk asyncio.run(main()) """ - async with self._raw_client.stream_data_context_with_envelope_schema( + async with self._raw_client.stream_x_fern_streaming_nullable_condition_stream( query=query, request_options=request_options ) as r: async for _chunk in r.data: yield _chunk - async def stream_oas_spec_native( + async def stream_x_fern_streaming_nullable_condition( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> CompletionFullResponse: + """ + Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + CompletionFullResponse + + + Examples + -------- + import asyncio + + from seed import AsyncSeedApi + + client = AsyncSeedApi( + base_url="https://yourhost.com/path/to/api", + ) + + + async def main() -> None: + await client.stream_x_fern_streaming_nullable_condition( + query="query", + ) + + + asyncio.run(main()) + """ + _response = await self._raw_client.stream_x_fern_streaming_nullable_condition( + query=query, request_options=request_options + ) + return _response.data + + async def stream_x_fern_streaming_sse_only( self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[Event]: + ) -> typing.AsyncIterator[str]: """ - Follows the pattern from the OAS 3.2 specification's own SSE example. The itemSchema extends a base Event schema via $ref and uses inline oneOf variants with const on the event field to distinguish event types. Data fields use contentSchema/contentMediaType for structured payloads. No discriminator object is used. Event type resolution relies on const matching. + Uses x-fern-streaming with format: sse but no stream-condition. This represents a stream-only endpoint that always returns SSE. There is no non-streaming variant, and the response is always a stream of chunks. Parameters ---------- @@ -665,8 +1611,8 @@ async def stream_oas_spec_native( Yields ------ - typing.AsyncIterator[Event] - SSE stream following the OAS 3.2 spec example pattern + typing.AsyncIterator[str] + SSE stream of completion chunks Examples -------- @@ -680,13 +1626,13 @@ async def stream_oas_spec_native( async def main() -> None: - response = await client.stream_oas_spec_native() + response = await client.stream_x_fern_streaming_sse_only() async for chunk in response: yield chunk asyncio.run(main()) """ - async with self._raw_client.stream_oas_spec_native(query=query, request_options=request_options) as r: + async with self._raw_client.stream_x_fern_streaming_sse_only(query=query, request_options=request_options) as r: async for _chunk in r.data: yield _chunk diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/raw_client.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/raw_client.py index 81500822a75..b385b53fead 100644 --- a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/raw_client.py +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/raw_client.py @@ -1,6 +1,7 @@ # This file was auto-generated by Fern from our API Definition. import contextlib +import json import typing from json.decoder import JSONDecodeError from logging import error, warning @@ -10,8 +11,11 @@ from .core.http_response import AsyncHttpResponse, HttpResponse from .core.http_sse._api import EventSource from .core.parse_error import ParsingError -from .core.pydantic_utilities import parse_sse_obj +from .core.pydantic_utilities import parse_obj_as, parse_sse_obj from .core.request_options import RequestOptions +from .core.serialization import convert_and_respect_annotation_metadata +from .types.completion_full_response import CompletionFullResponse +from .types.completion_stream_chunk import CompletionStreamChunk from .types.event import Event from .types.stream_data_context_response import StreamDataContextResponse from .types.stream_data_context_with_envelope_schema_response import StreamDataContextWithEnvelopeSchemaResponse @@ -19,6 +23,9 @@ from .types.stream_protocol_collision_response import StreamProtocolCollisionResponse from .types.stream_protocol_no_collision_response import StreamProtocolNoCollisionResponse from .types.stream_protocol_with_flat_schema_response import StreamProtocolWithFlatSchemaResponse +from .types.stream_x_fern_streaming_union_request import StreamXFernStreamingUnionRequest +from .types.stream_x_fern_streaming_union_stream_request import StreamXFernStreamingUnionStreamRequest +from .types.validate_union_request_response import ValidateUnionRequestResponse from pydantic import ValidationError # this is used as the default value for optional parameters @@ -582,17 +589,953 @@ def _iter(): yield _stream() + @contextlib.contextmanager + def stream_x_fern_streaming_condition_stream( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.Iterator[HttpResponse[typing.Iterator[CompletionStreamChunk]]]: + """ + Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[HttpResponse[typing.Iterator[CompletionStreamChunk]]] + + """ + with self._client_wrapper.httpx_client.stream( + "stream/x-fern-streaming-condition", + method="POST", + json={ + "query": query, + "stream": True, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + def _stream() -> HttpResponse[typing.Iterator[CompletionStreamChunk]]: + try: + if 200 <= _response.status_code < 300: + + def _iter(): + for _text in _response.iter_lines(): + try: + if len(_text) == 0: + continue + yield typing.cast( + CompletionStreamChunk, + parse_obj_as( + type_=CompletionStreamChunk, # type: ignore + object_=json.loads(_text), + ), + ) + except Exception: + pass + return + + return HttpResponse(response=_response, data=_iter()) + _response.read() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield _stream() + + def stream_x_fern_streaming_condition( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> HttpResponse[CompletionFullResponse]: + """ + Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + HttpResponse[CompletionFullResponse] + + """ + _response = self._client_wrapper.httpx_client.request( + "stream/x-fern-streaming-condition", + method="POST", + json={ + "query": query, + "stream": False, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return HttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + @contextlib.contextmanager + def stream_x_fern_streaming_shared_schema_stream( + self, *, prompt: str, model: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.Iterator[HttpResponse[typing.Iterator[CompletionStreamChunk]]]: + """ + Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. + + Parameters + ---------- + prompt : str + The prompt to complete. + + model : str + The model to use. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[HttpResponse[typing.Iterator[CompletionStreamChunk]]] + + """ + with self._client_wrapper.httpx_client.stream( + "stream/x-fern-streaming-shared-schema", + method="POST", + json={ + "prompt": prompt, + "model": model, + "stream": True, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + def _stream() -> HttpResponse[typing.Iterator[CompletionStreamChunk]]: + try: + if 200 <= _response.status_code < 300: + + def _iter(): + for _text in _response.iter_lines(): + try: + if len(_text) == 0: + continue + yield typing.cast( + CompletionStreamChunk, + parse_obj_as( + type_=CompletionStreamChunk, # type: ignore + object_=json.loads(_text), + ), + ) + except Exception: + pass + return + + return HttpResponse(response=_response, data=_iter()) + _response.read() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield _stream() + + def stream_x_fern_streaming_shared_schema( + self, *, prompt: str, model: str, request_options: typing.Optional[RequestOptions] = None + ) -> HttpResponse[CompletionFullResponse]: + """ + Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. + + Parameters + ---------- + prompt : str + The prompt to complete. + + model : str + The model to use. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + HttpResponse[CompletionFullResponse] + + """ + _response = self._client_wrapper.httpx_client.request( + "stream/x-fern-streaming-shared-schema", + method="POST", + json={ + "prompt": prompt, + "model": model, + "stream": False, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return HttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + def validate_completion( + self, + *, + prompt: str, + model: str, + stream: typing.Optional[bool] = OMIT, + request_options: typing.Optional[RequestOptions] = None, + ) -> HttpResponse[CompletionFullResponse]: + """ + A non-streaming endpoint that references the same SharedCompletionRequest schema as endpoint 10. Ensures the shared $ref schema remains available and is not excluded during the streaming endpoint's processing. + + Parameters + ---------- + prompt : str + The prompt to complete. + + model : str + The model to use. + + stream : typing.Optional[bool] + Whether to stream the response. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + HttpResponse[CompletionFullResponse] + Validation result + """ + _response = self._client_wrapper.httpx_client.request( + "validate-completion", + method="POST", + json={ + "prompt": prompt, + "model": model, + "stream": stream, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return HttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + @contextlib.contextmanager + def stream_x_fern_streaming_union_stream( + self, + *, + request: StreamXFernStreamingUnionStreamRequest, + request_options: typing.Optional[RequestOptions] = None, + ) -> typing.Iterator[HttpResponse[typing.Iterator[CompletionStreamChunk]]]: + """ + Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. + + Parameters + ---------- + request : StreamXFernStreamingUnionStreamRequest + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[HttpResponse[typing.Iterator[CompletionStreamChunk]]] + + """ + with self._client_wrapper.httpx_client.stream( + "stream/x-fern-streaming-union", + method="POST", + json=convert_and_respect_annotation_metadata( + object_=request, annotation=StreamXFernStreamingUnionStreamRequest, direction="write" + ), + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + def _stream() -> HttpResponse[typing.Iterator[CompletionStreamChunk]]: + try: + if 200 <= _response.status_code < 300: + + def _iter(): + for _text in _response.iter_lines(): + try: + if len(_text) == 0: + continue + yield typing.cast( + CompletionStreamChunk, + parse_obj_as( + type_=CompletionStreamChunk, # type: ignore + object_=json.loads(_text), + ), + ) + except Exception: + pass + return + + return HttpResponse(response=_response, data=_iter()) + _response.read() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield _stream() + + def stream_x_fern_streaming_union( + self, *, request: StreamXFernStreamingUnionRequest, request_options: typing.Optional[RequestOptions] = None + ) -> HttpResponse[CompletionFullResponse]: + """ + Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. + + Parameters + ---------- + request : StreamXFernStreamingUnionRequest + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + HttpResponse[CompletionFullResponse] + + """ + _response = self._client_wrapper.httpx_client.request( + "stream/x-fern-streaming-union", + method="POST", + json=convert_and_respect_annotation_metadata( + object_=request, annotation=StreamXFernStreamingUnionRequest, direction="write" + ), + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return HttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + def validate_union_request( + self, + *, + prompt: str, + stream_response: typing.Optional[bool] = OMIT, + request_options: typing.Optional[RequestOptions] = None, + ) -> HttpResponse[ValidateUnionRequestResponse]: + """ + References UnionStreamRequestBase directly, ensuring the base schema cannot be excluded from the context. This endpoint exists to verify that shared base schemas used in discriminated union variants with stream-condition remain available. + + Parameters + ---------- + prompt : str + The input prompt. + + stream_response : typing.Optional[bool] + Whether to stream the response. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + HttpResponse[ValidateUnionRequestResponse] + Validation result + """ + _response = self._client_wrapper.httpx_client.request( + "validate-union-request", + method="POST", + json={ + "stream_response": stream_response, + "prompt": prompt, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + ValidateUnionRequestResponse, + parse_obj_as( + type_=ValidateUnionRequestResponse, # type: ignore + object_=_response.json(), + ), + ) + return HttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + @contextlib.contextmanager + def stream_x_fern_streaming_nullable_condition_stream( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.Iterator[HttpResponse[typing.Iterator[CompletionStreamChunk]]]: + """ + Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[HttpResponse[typing.Iterator[CompletionStreamChunk]]] + + """ + with self._client_wrapper.httpx_client.stream( + "stream/x-fern-streaming-nullable-condition", + method="POST", + json={ + "query": query, + "stream": True, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + def _stream() -> HttpResponse[typing.Iterator[CompletionStreamChunk]]: + try: + if 200 <= _response.status_code < 300: + + def _iter(): + for _text in _response.iter_lines(): + try: + if len(_text) == 0: + continue + yield typing.cast( + CompletionStreamChunk, + parse_obj_as( + type_=CompletionStreamChunk, # type: ignore + object_=json.loads(_text), + ), + ) + except Exception: + pass + return + + return HttpResponse(response=_response, data=_iter()) + _response.read() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield _stream() + + def stream_x_fern_streaming_nullable_condition( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> HttpResponse[CompletionFullResponse]: + """ + Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + HttpResponse[CompletionFullResponse] + + """ + _response = self._client_wrapper.httpx_client.request( + "stream/x-fern-streaming-nullable-condition", + method="POST", + json={ + "query": query, + "stream": False, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return HttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + @contextlib.contextmanager + def stream_x_fern_streaming_sse_only( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.Iterator[HttpResponse[typing.Iterator[str]]]: + """ + Uses x-fern-streaming with format: sse but no stream-condition. This represents a stream-only endpoint that always returns SSE. There is no non-streaming variant, and the response is always a stream of chunks. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.Iterator[HttpResponse[typing.Iterator[str]]] + SSE stream of completion chunks + """ + with self._client_wrapper.httpx_client.stream( + "stream/x-fern-streaming-sse-only", + method="POST", + json={ + "query": query, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + def _stream() -> HttpResponse[typing.Iterator[str]]: + try: + if 200 <= _response.status_code < 300: + + def _iter(): + _event_source = EventSource(_response) + for _sse in _event_source.iter_sse(): + if _sse.data == None: + return + try: + yield typing.cast( + str, + parse_sse_obj( + sse=_sse, + type_=str, # type: ignore + ), + ) + except JSONDecodeError as e: + warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") + except (TypeError, ValueError, KeyError, AttributeError) as e: + warning( + f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + except Exception as e: + error( + f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + return + + return HttpResponse(response=_response, data=_iter()) + _response.read() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield _stream() + + +class AsyncRawSeedApi: + def __init__(self, *, client_wrapper: AsyncClientWrapper): + self._client_wrapper = client_wrapper + + @contextlib.asynccontextmanager + async def stream_protocol_no_collision( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolNoCollisionResponse]]]: + """ + Uses discriminator with mapping, x-fern-discriminator-context set to protocol. Because the discriminant is at the protocol level, the data field can be any type or absent entirely. Demonstrates heartbeat (no data), string literal, number literal, and object data payloads. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolNoCollisionResponse]]] + SSE stream with protocol-level discrimination and mixed data types + """ + async with self._client_wrapper.httpx_client.stream( + "stream/protocol-no-collision", + method="POST", + json={ + "query": query, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamProtocolNoCollisionResponse]]: + try: + if 200 <= _response.status_code < 300: + + async def _iter(): + _event_source = EventSource(_response) + async for _sse in _event_source.aiter_sse(): + if _sse.data == None: + return + try: + yield typing.cast( + StreamProtocolNoCollisionResponse, + parse_sse_obj( + sse=_sse, + type_=StreamProtocolNoCollisionResponse, # type: ignore + ), + ) + except JSONDecodeError as e: + warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") + except (TypeError, ValueError, KeyError, AttributeError) as e: + warning( + f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + except Exception as e: + error( + f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + return + + return AsyncHttpResponse(response=_response, data=_iter()) + await _response.aread() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield await _stream() + + @contextlib.asynccontextmanager + async def stream_protocol_collision( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolCollisionResponse]]]: + """ + Same as endpoint 1, but the object data payload contains its own "event" property, which collides with the SSE envelope's "event" discriminator field. Tests whether generators correctly separate the protocol-level discriminant from the data-level field when context=protocol is specified. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolCollisionResponse]]] + SSE stream with protocol context and event field collision + """ + async with self._client_wrapper.httpx_client.stream( + "stream/protocol-collision", + method="POST", + json={ + "query": query, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamProtocolCollisionResponse]]: + try: + if 200 <= _response.status_code < 300: + + async def _iter(): + _event_source = EventSource(_response) + async for _sse in _event_source.aiter_sse(): + if _sse.data == None: + return + try: + yield typing.cast( + StreamProtocolCollisionResponse, + parse_sse_obj( + sse=_sse, + type_=StreamProtocolCollisionResponse, # type: ignore + ), + ) + except JSONDecodeError as e: + warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") + except (TypeError, ValueError, KeyError, AttributeError) as e: + warning( + f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + except Exception as e: + error( + f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + return + + return AsyncHttpResponse(response=_response, data=_iter()) + await _response.aread() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield await _stream() + + @contextlib.asynccontextmanager + async def stream_data_context( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamDataContextResponse]]]: + """ + x-fern-discriminator-context is explicitly set to "data" (the default value). Each variant uses allOf to extend a payload schema and adds the "event" discriminant property at the same level. There is no "data" wrapper. The discriminant and payload fields coexist in a single flat object. This matches the real-world pattern used by customers with context=data. -class AsyncRawSeedApi: - def __init__(self, *, client_wrapper: AsyncClientWrapper): - self._client_wrapper = client_wrapper + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamDataContextResponse]]] + SSE stream with discriminator context set to data + """ + async with self._client_wrapper.httpx_client.stream( + "stream/data-context", + method="POST", + json={ + "query": query, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamDataContextResponse]]: + try: + if 200 <= _response.status_code < 300: + + async def _iter(): + _event_source = EventSource(_response) + async for _sse in _event_source.aiter_sse(): + if _sse.data == None: + return + try: + yield typing.cast( + StreamDataContextResponse, + parse_sse_obj( + sse=_sse, + type_=StreamDataContextResponse, # type: ignore + ), + ) + except JSONDecodeError as e: + warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") + except (TypeError, ValueError, KeyError, AttributeError) as e: + warning( + f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + except Exception as e: + error( + f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + return + + return AsyncHttpResponse(response=_response, data=_iter()) + await _response.aread() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield await _stream() @contextlib.asynccontextmanager - async def stream_protocol_no_collision( + async def stream_no_context( self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolNoCollisionResponse]]]: + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamNoContextResponse]]]: """ - Uses discriminator with mapping, x-fern-discriminator-context set to protocol. Because the discriminant is at the protocol level, the data field can be any type or absent entirely. Demonstrates heartbeat (no data), string literal, number literal, and object data payloads. + The x-fern-discriminator-context extension is omitted entirely. Tests whether Fern correctly infers the default behavior (context=data) when the extension is absent. Same flat allOf pattern as endpoint 3. Parameters ---------- @@ -603,11 +1546,11 @@ async def stream_protocol_no_collision( Yields ------ - typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolNoCollisionResponse]]] - SSE stream with protocol-level discrimination and mixed data types + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamNoContextResponse]]] + SSE stream with no discriminator context hint """ async with self._client_wrapper.httpx_client.stream( - "stream/protocol-no-collision", + "stream/no-context", method="POST", json={ "query": query, @@ -619,7 +1562,7 @@ async def stream_protocol_no_collision( omit=OMIT, ) as _response: - async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamProtocolNoCollisionResponse]]: + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamNoContextResponse]]: try: if 200 <= _response.status_code < 300: @@ -630,10 +1573,10 @@ async def _iter(): return try: yield typing.cast( - StreamProtocolNoCollisionResponse, + StreamNoContextResponse, parse_sse_obj( sse=_sse, - type_=StreamProtocolNoCollisionResponse, # type: ignore + type_=StreamNoContextResponse, # type: ignore ), ) except JSONDecodeError as e: @@ -667,11 +1610,169 @@ async def _iter(): yield await _stream() @contextlib.asynccontextmanager - async def stream_protocol_collision( + async def stream_protocol_with_flat_schema( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse]]]: + """ + Mismatched combination: context=protocol with the flat allOf schema pattern that is normally used with context=data. Shows what happens when the discriminant is declared as protocol-level but the schema uses allOf to flatten the event field alongside payload fields instead of wrapping them in a data field. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse]]] + SSE stream with protocol context but flat allOf schemas + """ + async with self._client_wrapper.httpx_client.stream( + "stream/protocol-with-flat-schema", + method="POST", + json={ + "query": query, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse]]: + try: + if 200 <= _response.status_code < 300: + + async def _iter(): + _event_source = EventSource(_response) + async for _sse in _event_source.aiter_sse(): + if _sse.data == None: + return + try: + yield typing.cast( + StreamProtocolWithFlatSchemaResponse, + parse_sse_obj( + sse=_sse, + type_=StreamProtocolWithFlatSchemaResponse, # type: ignore + ), + ) + except JSONDecodeError as e: + warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") + except (TypeError, ValueError, KeyError, AttributeError) as e: + warning( + f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + except Exception as e: + error( + f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + return + + return AsyncHttpResponse(response=_response, data=_iter()) + await _response.aread() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield await _stream() + + @contextlib.asynccontextmanager + async def stream_data_context_with_envelope_schema( + self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse]]]: + """ + Mismatched combination: context=data with the envelope+data schema pattern that is normally used with context=protocol. Shows what happens when the discriminant is declared as data-level but the schema separates the event field and data field into an envelope structure. + + Parameters + ---------- + query : typing.Optional[str] + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Yields + ------ + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse]]] + SSE stream with data context but envelope+data schemas + """ + async with self._client_wrapper.httpx_client.stream( + "stream/data-context-with-envelope-schema", + method="POST", + json={ + "query": query, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) as _response: + + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse]]: + try: + if 200 <= _response.status_code < 300: + + async def _iter(): + _event_source = EventSource(_response) + async for _sse in _event_source.aiter_sse(): + if _sse.data == None: + return + try: + yield typing.cast( + StreamDataContextWithEnvelopeSchemaResponse, + parse_sse_obj( + sse=_sse, + type_=StreamDataContextWithEnvelopeSchemaResponse, # type: ignore + ), + ) + except JSONDecodeError as e: + warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") + except (TypeError, ValueError, KeyError, AttributeError) as e: + warning( + f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + except Exception as e: + error( + f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" + ) + return + + return AsyncHttpResponse(response=_response, data=_iter()) + await _response.aread() + _response_json = _response.json() + except JSONDecodeError: + raise ApiError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.text + ) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, + headers=dict(_response.headers), + body=_response.json(), + cause=e, + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + yield await _stream() + + @contextlib.asynccontextmanager + async def stream_oas_spec_native( self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolCollisionResponse]]]: + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[Event]]]: """ - Same as endpoint 1, but the object data payload contains its own "event" property, which collides with the SSE envelope's "event" discriminator field. Tests whether generators correctly separate the protocol-level discriminant from the data-level field when context=protocol is specified. + Follows the pattern from the OAS 3.2 specification's own SSE example. The itemSchema extends a base Event schema via $ref and uses inline oneOf variants with const on the event field to distinguish event types. Data fields use contentSchema/contentMediaType for structured payloads. No discriminator object is used. Event type resolution relies on const matching. Parameters ---------- @@ -682,11 +1783,11 @@ async def stream_protocol_collision( Yields ------ - typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolCollisionResponse]]] - SSE stream with protocol context and event field collision + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[Event]]] + SSE stream following the OAS 3.2 spec example pattern """ async with self._client_wrapper.httpx_client.stream( - "stream/protocol-collision", + "stream/oas-spec-native", method="POST", json={ "query": query, @@ -698,7 +1799,7 @@ async def stream_protocol_collision( omit=OMIT, ) as _response: - async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamProtocolCollisionResponse]]: + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[Event]]: try: if 200 <= _response.status_code < 300: @@ -709,10 +1810,10 @@ async def _iter(): return try: yield typing.cast( - StreamProtocolCollisionResponse, + Event, parse_sse_obj( sse=_sse, - type_=StreamProtocolCollisionResponse, # type: ignore + type_=Event, # type: ignore ), ) except JSONDecodeError as e: @@ -746,29 +1847,31 @@ async def _iter(): yield await _stream() @contextlib.asynccontextmanager - async def stream_data_context( - self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamDataContextResponse]]]: + async def stream_x_fern_streaming_condition_stream( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]]: """ - x-fern-discriminator-context is explicitly set to "data" (the default value). Each variant uses allOf to extend a payload schema and adds the "event" discriminant property at the same level. There is no "data" wrapper. The discriminant and payload fields coexist in a single flat object. This matches the real-world pattern used by customers with context=data. + Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. Parameters ---------- - query : typing.Optional[str] + query : str + The prompt or query to complete. request_options : typing.Optional[RequestOptions] Request-specific configuration. Yields ------ - typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamDataContextResponse]]] - SSE stream with discriminator context set to data + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]] + """ async with self._client_wrapper.httpx_client.stream( - "stream/data-context", + "stream/x-fern-streaming-condition", method="POST", json={ "query": query, + "stream": True, }, headers={ "content-type": "application/json", @@ -777,33 +1880,24 @@ async def stream_data_context( omit=OMIT, ) as _response: - async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamDataContextResponse]]: + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]: try: if 200 <= _response.status_code < 300: async def _iter(): - _event_source = EventSource(_response) - async for _sse in _event_source.aiter_sse(): - if _sse.data == None: - return + async for _text in _response.aiter_lines(): try: + if len(_text) == 0: + continue yield typing.cast( - StreamDataContextResponse, - parse_sse_obj( - sse=_sse, - type_=StreamDataContextResponse, # type: ignore + CompletionStreamChunk, + parse_obj_as( + type_=CompletionStreamChunk, # type: ignore + object_=json.loads(_text), ), ) - except JSONDecodeError as e: - warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") - except (TypeError, ValueError, KeyError, AttributeError) as e: - warning( - f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" - ) - except Exception as e: - error( - f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" - ) + except Exception: + pass return return AsyncHttpResponse(response=_response, data=_iter()) @@ -824,30 +1918,87 @@ async def _iter(): yield await _stream() + async def stream_x_fern_streaming_condition( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> AsyncHttpResponse[CompletionFullResponse]: + """ + Uses x-fern-streaming extension with stream-condition to split into streaming and non-streaming variants based on a request body field. The request body is a $ref to a named schema. The response and response-stream point to different schemas. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + AsyncHttpResponse[CompletionFullResponse] + + """ + _response = await self._client_wrapper.httpx_client.request( + "stream/x-fern-streaming-condition", + method="POST", + json={ + "query": query, + "stream": False, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return AsyncHttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + @contextlib.asynccontextmanager - async def stream_no_context( - self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamNoContextResponse]]]: + async def stream_x_fern_streaming_shared_schema_stream( + self, *, prompt: str, model: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]]: """ - The x-fern-discriminator-context extension is omitted entirely. Tests whether Fern correctly infers the default behavior (context=data) when the extension is absent. Same flat allOf pattern as endpoint 3. + Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. Parameters ---------- - query : typing.Optional[str] + prompt : str + The prompt to complete. + + model : str + The model to use. request_options : typing.Optional[RequestOptions] Request-specific configuration. Yields ------ - typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamNoContextResponse]]] - SSE stream with no discriminator context hint + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]] + """ async with self._client_wrapper.httpx_client.stream( - "stream/no-context", + "stream/x-fern-streaming-shared-schema", method="POST", json={ - "query": query, + "prompt": prompt, + "model": model, + "stream": True, }, headers={ "content-type": "application/json", @@ -856,33 +2007,24 @@ async def stream_no_context( omit=OMIT, ) as _response: - async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamNoContextResponse]]: + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]: try: if 200 <= _response.status_code < 300: async def _iter(): - _event_source = EventSource(_response) - async for _sse in _event_source.aiter_sse(): - if _sse.data == None: - return + async for _text in _response.aiter_lines(): try: + if len(_text) == 0: + continue yield typing.cast( - StreamNoContextResponse, - parse_sse_obj( - sse=_sse, - type_=StreamNoContextResponse, # type: ignore + CompletionStreamChunk, + parse_obj_as( + type_=CompletionStreamChunk, # type: ignore + object_=json.loads(_text), ), ) - except JSONDecodeError as e: - warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") - except (TypeError, ValueError, KeyError, AttributeError) as e: - warning( - f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" - ) - except Exception as e: - error( - f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" - ) + except Exception: + pass return return AsyncHttpResponse(response=_response, data=_iter()) @@ -903,31 +2045,152 @@ async def _iter(): yield await _stream() + async def stream_x_fern_streaming_shared_schema( + self, *, prompt: str, model: str, request_options: typing.Optional[RequestOptions] = None + ) -> AsyncHttpResponse[CompletionFullResponse]: + """ + Uses x-fern-streaming with stream-condition. The request body $ref (SharedCompletionRequest) is also referenced by a separate non-streaming endpoint (/validate-completion). This tests that the shared request schema is not excluded from the context during streaming processing. + + Parameters + ---------- + prompt : str + The prompt to complete. + + model : str + The model to use. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + AsyncHttpResponse[CompletionFullResponse] + + """ + _response = await self._client_wrapper.httpx_client.request( + "stream/x-fern-streaming-shared-schema", + method="POST", + json={ + "prompt": prompt, + "model": model, + "stream": False, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return AsyncHttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + async def validate_completion( + self, + *, + prompt: str, + model: str, + stream: typing.Optional[bool] = OMIT, + request_options: typing.Optional[RequestOptions] = None, + ) -> AsyncHttpResponse[CompletionFullResponse]: + """ + A non-streaming endpoint that references the same SharedCompletionRequest schema as endpoint 10. Ensures the shared $ref schema remains available and is not excluded during the streaming endpoint's processing. + + Parameters + ---------- + prompt : str + The prompt to complete. + + model : str + The model to use. + + stream : typing.Optional[bool] + Whether to stream the response. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + AsyncHttpResponse[CompletionFullResponse] + Validation result + """ + _response = await self._client_wrapper.httpx_client.request( + "validate-completion", + method="POST", + json={ + "prompt": prompt, + "model": model, + "stream": stream, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return AsyncHttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + @contextlib.asynccontextmanager - async def stream_protocol_with_flat_schema( - self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse]]]: + async def stream_x_fern_streaming_union_stream( + self, + *, + request: StreamXFernStreamingUnionStreamRequest, + request_options: typing.Optional[RequestOptions] = None, + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]]: """ - Mismatched combination: context=protocol with the flat allOf schema pattern that is normally used with context=data. Shows what happens when the discriminant is declared as protocol-level but the schema uses allOf to flatten the event field alongside payload fields instead of wrapping them in a data field. + Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. Parameters ---------- - query : typing.Optional[str] + request : StreamXFernStreamingUnionStreamRequest request_options : typing.Optional[RequestOptions] Request-specific configuration. Yields ------ - typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse]]] - SSE stream with protocol context but flat allOf schemas + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]] + """ async with self._client_wrapper.httpx_client.stream( - "stream/protocol-with-flat-schema", + "stream/x-fern-streaming-union", method="POST", - json={ - "query": query, - }, + json=convert_and_respect_annotation_metadata( + object_=request, annotation=StreamXFernStreamingUnionStreamRequest, direction="write" + ), headers={ "content-type": "application/json", }, @@ -935,33 +2198,24 @@ async def stream_protocol_with_flat_schema( omit=OMIT, ) as _response: - async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamProtocolWithFlatSchemaResponse]]: + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]: try: if 200 <= _response.status_code < 300: async def _iter(): - _event_source = EventSource(_response) - async for _sse in _event_source.aiter_sse(): - if _sse.data == None: - return + async for _text in _response.aiter_lines(): try: + if len(_text) == 0: + continue yield typing.cast( - StreamProtocolWithFlatSchemaResponse, - parse_sse_obj( - sse=_sse, - type_=StreamProtocolWithFlatSchemaResponse, # type: ignore + CompletionStreamChunk, + parse_obj_as( + type_=CompletionStreamChunk, # type: ignore + object_=json.loads(_text), ), ) - except JSONDecodeError as e: - warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") - except (TypeError, ValueError, KeyError, AttributeError) as e: - warning( - f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" - ) - except Exception as e: - error( - f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" - ) + except Exception: + pass return return AsyncHttpResponse(response=_response, data=_iter()) @@ -982,30 +2236,139 @@ async def _iter(): yield await _stream() + async def stream_x_fern_streaming_union( + self, *, request: StreamXFernStreamingUnionRequest, request_options: typing.Optional[RequestOptions] = None + ) -> AsyncHttpResponse[CompletionFullResponse]: + """ + Uses x-fern-streaming with stream-condition where the request body is a discriminated union (oneOf) whose variants inherit the stream condition field (stream_response) from a shared base schema via allOf. Tests that the stream condition property is not duplicated in the generated output when the base schema is expanded into each variant. + + Parameters + ---------- + request : StreamXFernStreamingUnionRequest + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + AsyncHttpResponse[CompletionFullResponse] + + """ + _response = await self._client_wrapper.httpx_client.request( + "stream/x-fern-streaming-union", + method="POST", + json=convert_and_respect_annotation_metadata( + object_=request, annotation=StreamXFernStreamingUnionRequest, direction="write" + ), + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return AsyncHttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + + async def validate_union_request( + self, + *, + prompt: str, + stream_response: typing.Optional[bool] = OMIT, + request_options: typing.Optional[RequestOptions] = None, + ) -> AsyncHttpResponse[ValidateUnionRequestResponse]: + """ + References UnionStreamRequestBase directly, ensuring the base schema cannot be excluded from the context. This endpoint exists to verify that shared base schemas used in discriminated union variants with stream-condition remain available. + + Parameters + ---------- + prompt : str + The input prompt. + + stream_response : typing.Optional[bool] + Whether to stream the response. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + AsyncHttpResponse[ValidateUnionRequestResponse] + Validation result + """ + _response = await self._client_wrapper.httpx_client.request( + "validate-union-request", + method="POST", + json={ + "stream_response": stream_response, + "prompt": prompt, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + ValidateUnionRequestResponse, + parse_obj_as( + type_=ValidateUnionRequestResponse, # type: ignore + object_=_response.json(), + ), + ) + return AsyncHttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + @contextlib.asynccontextmanager - async def stream_data_context_with_envelope_schema( - self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse]]]: + async def stream_x_fern_streaming_nullable_condition_stream( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]]: """ - Mismatched combination: context=data with the envelope+data schema pattern that is normally used with context=protocol. Shows what happens when the discriminant is declared as data-level but the schema separates the event field and data field into an envelope structure. + Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. Parameters ---------- - query : typing.Optional[str] + query : str + The prompt or query to complete. request_options : typing.Optional[RequestOptions] Request-specific configuration. Yields ------ - typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse]]] - SSE stream with data context but envelope+data schemas + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]] + """ async with self._client_wrapper.httpx_client.stream( - "stream/data-context-with-envelope-schema", + "stream/x-fern-streaming-nullable-condition", method="POST", json={ "query": query, + "stream": True, }, headers={ "content-type": "application/json", @@ -1014,33 +2377,24 @@ async def stream_data_context_with_envelope_schema( omit=OMIT, ) as _response: - async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[StreamDataContextWithEnvelopeSchemaResponse]]: + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[CompletionStreamChunk]]: try: if 200 <= _response.status_code < 300: async def _iter(): - _event_source = EventSource(_response) - async for _sse in _event_source.aiter_sse(): - if _sse.data == None: - return + async for _text in _response.aiter_lines(): try: + if len(_text) == 0: + continue yield typing.cast( - StreamDataContextWithEnvelopeSchemaResponse, - parse_sse_obj( - sse=_sse, - type_=StreamDataContextWithEnvelopeSchemaResponse, # type: ignore + CompletionStreamChunk, + parse_obj_as( + type_=CompletionStreamChunk, # type: ignore + object_=json.loads(_text), ), ) - except JSONDecodeError as e: - warning(f"Skipping SSE event with invalid JSON: {e}, sse: {_sse!r}") - except (TypeError, ValueError, KeyError, AttributeError) as e: - warning( - f"Skipping SSE event due to model construction error: {type(e).__name__}: {e}, sse: {_sse!r}" - ) - except Exception as e: - error( - f"Unexpected error processing SSE event: {type(e).__name__}: {e}, sse: {_sse!r}" - ) + except Exception: + pass return return AsyncHttpResponse(response=_response, data=_iter()) @@ -1061,12 +2415,63 @@ async def _iter(): yield await _stream() + async def stream_x_fern_streaming_nullable_condition( + self, *, query: str, request_options: typing.Optional[RequestOptions] = None + ) -> AsyncHttpResponse[CompletionFullResponse]: + """ + Uses x-fern-streaming with stream-condition where the stream field is nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread order in the importer caused the nullable type array to overwrite the const literal, producing stream?: true | null instead of stream: true. The const/type override must be spread after the original property. + + Parameters + ---------- + query : str + The prompt or query to complete. + + request_options : typing.Optional[RequestOptions] + Request-specific configuration. + + Returns + ------- + AsyncHttpResponse[CompletionFullResponse] + + """ + _response = await self._client_wrapper.httpx_client.request( + "stream/x-fern-streaming-nullable-condition", + method="POST", + json={ + "query": query, + "stream": False, + }, + headers={ + "content-type": "application/json", + }, + request_options=request_options, + omit=OMIT, + ) + try: + if 200 <= _response.status_code < 300: + _data = typing.cast( + CompletionFullResponse, + parse_obj_as( + type_=CompletionFullResponse, # type: ignore + object_=_response.json(), + ), + ) + return AsyncHttpResponse(response=_response, data=_data) + _response_json = _response.json() + except JSONDecodeError: + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text) + except ValidationError as e: + raise ParsingError( + status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e + ) + raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json) + @contextlib.asynccontextmanager - async def stream_oas_spec_native( + async def stream_x_fern_streaming_sse_only( self, *, query: typing.Optional[str] = OMIT, request_options: typing.Optional[RequestOptions] = None - ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[Event]]]: + ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[str]]]: """ - Follows the pattern from the OAS 3.2 specification's own SSE example. The itemSchema extends a base Event schema via $ref and uses inline oneOf variants with const on the event field to distinguish event types. Data fields use contentSchema/contentMediaType for structured payloads. No discriminator object is used. Event type resolution relies on const matching. + Uses x-fern-streaming with format: sse but no stream-condition. This represents a stream-only endpoint that always returns SSE. There is no non-streaming variant, and the response is always a stream of chunks. Parameters ---------- @@ -1077,11 +2482,11 @@ async def stream_oas_spec_native( Yields ------ - typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[Event]]] - SSE stream following the OAS 3.2 spec example pattern + typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[str]]] + SSE stream of completion chunks """ async with self._client_wrapper.httpx_client.stream( - "stream/oas-spec-native", + "stream/x-fern-streaming-sse-only", method="POST", json={ "query": query, @@ -1093,7 +2498,7 @@ async def stream_oas_spec_native( omit=OMIT, ) as _response: - async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[Event]]: + async def _stream() -> AsyncHttpResponse[typing.AsyncIterator[str]]: try: if 200 <= _response.status_code < 300: @@ -1104,10 +2509,10 @@ async def _iter(): return try: yield typing.cast( - Event, + str, parse_sse_obj( sse=_sse, - type_=Event, # type: ignore + type_=str, # type: ignore ), ) except JSONDecodeError as e: diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/__init__.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/__init__.py index f6b5a60a6dc..40d42cdbb18 100644 --- a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/__init__.py +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/__init__.py @@ -6,12 +6,17 @@ from importlib import import_module if typing.TYPE_CHECKING: + from .completion_full_response import CompletionFullResponse + from .completion_full_response_finish_reason import CompletionFullResponseFinishReason + from .completion_request import CompletionRequest + from .completion_stream_chunk import CompletionStreamChunk from .data_context_entity_event import DataContextEntityEvent from .data_context_heartbeat import DataContextHeartbeat from .entity_event_payload import EntityEventPayload from .entity_event_payload_event_type import EntityEventPayloadEventType from .event import Event from .heartbeat_payload import HeartbeatPayload + from .nullable_stream_request import NullableStreamRequest from .object_payload_with_event_field import ObjectPayloadWithEventField from .protocol_collision_object_event import ProtocolCollisionObjectEvent from .protocol_heartbeat import ProtocolHeartbeat @@ -56,13 +61,41 @@ StreamProtocolWithFlatSchemaResponse_Heartbeat, ) from .stream_request import StreamRequest + from .stream_x_fern_streaming_union_request import ( + StreamXFernStreamingUnionRequest, + StreamXFernStreamingUnionRequest_Compact, + StreamXFernStreamingUnionRequest_Interrupt, + StreamXFernStreamingUnionRequest_Message, + ) + from .stream_x_fern_streaming_union_stream_request import ( + StreamXFernStreamingUnionStreamRequest, + StreamXFernStreamingUnionStreamRequest_Compact, + StreamXFernStreamingUnionStreamRequest_Interrupt, + StreamXFernStreamingUnionStreamRequest_Message, + ) + from .union_stream_compact_variant import UnionStreamCompactVariant + from .union_stream_interrupt_variant import UnionStreamInterruptVariant + from .union_stream_message_variant import UnionStreamMessageVariant + from .union_stream_request import ( + UnionStreamRequest, + UnionStreamRequest_Compact, + UnionStreamRequest_Interrupt, + UnionStreamRequest_Message, + ) + from .union_stream_request_base import UnionStreamRequestBase + from .validate_union_request_response import ValidateUnionRequestResponse _dynamic_imports: typing.Dict[str, str] = { + "CompletionFullResponse": ".completion_full_response", + "CompletionFullResponseFinishReason": ".completion_full_response_finish_reason", + "CompletionRequest": ".completion_request", + "CompletionStreamChunk": ".completion_stream_chunk", "DataContextEntityEvent": ".data_context_entity_event", "DataContextHeartbeat": ".data_context_heartbeat", "EntityEventPayload": ".entity_event_payload", "EntityEventPayloadEventType": ".entity_event_payload_event_type", "Event": ".event", "HeartbeatPayload": ".heartbeat_payload", + "NullableStreamRequest": ".nullable_stream_request", "ObjectPayloadWithEventField": ".object_payload_with_event_field", "ProtocolCollisionObjectEvent": ".protocol_collision_object_event", "ProtocolHeartbeat": ".protocol_heartbeat", @@ -95,6 +128,23 @@ "StreamProtocolWithFlatSchemaResponse_Entity": ".stream_protocol_with_flat_schema_response", "StreamProtocolWithFlatSchemaResponse_Heartbeat": ".stream_protocol_with_flat_schema_response", "StreamRequest": ".stream_request", + "StreamXFernStreamingUnionRequest": ".stream_x_fern_streaming_union_request", + "StreamXFernStreamingUnionRequest_Compact": ".stream_x_fern_streaming_union_request", + "StreamXFernStreamingUnionRequest_Interrupt": ".stream_x_fern_streaming_union_request", + "StreamXFernStreamingUnionRequest_Message": ".stream_x_fern_streaming_union_request", + "StreamXFernStreamingUnionStreamRequest": ".stream_x_fern_streaming_union_stream_request", + "StreamXFernStreamingUnionStreamRequest_Compact": ".stream_x_fern_streaming_union_stream_request", + "StreamXFernStreamingUnionStreamRequest_Interrupt": ".stream_x_fern_streaming_union_stream_request", + "StreamXFernStreamingUnionStreamRequest_Message": ".stream_x_fern_streaming_union_stream_request", + "UnionStreamCompactVariant": ".union_stream_compact_variant", + "UnionStreamInterruptVariant": ".union_stream_interrupt_variant", + "UnionStreamMessageVariant": ".union_stream_message_variant", + "UnionStreamRequest": ".union_stream_request", + "UnionStreamRequestBase": ".union_stream_request_base", + "UnionStreamRequest_Compact": ".union_stream_request", + "UnionStreamRequest_Interrupt": ".union_stream_request", + "UnionStreamRequest_Message": ".union_stream_request", + "ValidateUnionRequestResponse": ".validate_union_request_response", } @@ -120,12 +170,17 @@ def __dir__(): __all__ = [ + "CompletionFullResponse", + "CompletionFullResponseFinishReason", + "CompletionRequest", + "CompletionStreamChunk", "DataContextEntityEvent", "DataContextHeartbeat", "EntityEventPayload", "EntityEventPayloadEventType", "Event", "HeartbeatPayload", + "NullableStreamRequest", "ObjectPayloadWithEventField", "ProtocolCollisionObjectEvent", "ProtocolHeartbeat", @@ -158,4 +213,21 @@ def __dir__(): "StreamProtocolWithFlatSchemaResponse_Entity", "StreamProtocolWithFlatSchemaResponse_Heartbeat", "StreamRequest", + "StreamXFernStreamingUnionRequest", + "StreamXFernStreamingUnionRequest_Compact", + "StreamXFernStreamingUnionRequest_Interrupt", + "StreamXFernStreamingUnionRequest_Message", + "StreamXFernStreamingUnionStreamRequest", + "StreamXFernStreamingUnionStreamRequest_Compact", + "StreamXFernStreamingUnionStreamRequest_Interrupt", + "StreamXFernStreamingUnionStreamRequest_Message", + "UnionStreamCompactVariant", + "UnionStreamInterruptVariant", + "UnionStreamMessageVariant", + "UnionStreamRequest", + "UnionStreamRequestBase", + "UnionStreamRequest_Compact", + "UnionStreamRequest_Interrupt", + "UnionStreamRequest_Message", + "ValidateUnionRequestResponse", ] diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_full_response.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_full_response.py new file mode 100644 index 00000000000..2a6c393e2ca --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_full_response.py @@ -0,0 +1,35 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +import pydantic +import typing_extensions +from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel +from ..core.serialization import FieldMetadata +from .completion_full_response_finish_reason import CompletionFullResponseFinishReason + + +class CompletionFullResponse(UniversalBaseModel): + """ + Full response returned when streaming is disabled. + """ + + answer: typing.Optional[str] = pydantic.Field(default=None) + """ + The complete generated answer. + """ + + finish_reason: typing_extensions.Annotated[ + typing.Optional[CompletionFullResponseFinishReason], + FieldMetadata(alias="finishReason"), + pydantic.Field(alias="finishReason", description="Why generation stopped."), + ] = None + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_full_response_finish_reason.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_full_response_finish_reason.py new file mode 100644 index 00000000000..0e6ab0407a0 --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_full_response_finish_reason.py @@ -0,0 +1,5 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +CompletionFullResponseFinishReason = typing.Union[typing.Literal["complete", "length", "error"], typing.Any] diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_request.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_request.py new file mode 100644 index 00000000000..20a7c0c1129 --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_request.py @@ -0,0 +1,27 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +import pydantic +from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel + + +class CompletionRequest(UniversalBaseModel): + query: str = pydantic.Field() + """ + The prompt or query to complete. + """ + + stream: typing.Optional[bool] = pydantic.Field(default=None) + """ + Whether to stream the response. + """ + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_stream_chunk.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_stream_chunk.py new file mode 100644 index 00000000000..1922ac05424 --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/completion_stream_chunk.py @@ -0,0 +1,31 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +import pydantic +from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel + + +class CompletionStreamChunk(UniversalBaseModel): + """ + A single chunk in a streamed completion response. + """ + + delta: typing.Optional[str] = pydantic.Field(default=None) + """ + The incremental text chunk. + """ + + tokens: typing.Optional[int] = pydantic.Field(default=None) + """ + Number of tokens in this chunk. + """ + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/nullable_stream_request.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/nullable_stream_request.py new file mode 100644 index 00000000000..326054bad92 --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/nullable_stream_request.py @@ -0,0 +1,27 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +import pydantic +from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel + + +class NullableStreamRequest(UniversalBaseModel): + query: str = pydantic.Field() + """ + The prompt or query to complete. + """ + + stream: typing.Optional[bool] = pydantic.Field(default=None) + """ + Whether to stream the response. This field is nullable (OAS 3.1 type array), which previously caused the const literal to be overwritten by the nullable type during spread in the importer. + """ + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/stream_x_fern_streaming_union_request.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/stream_x_fern_streaming_union_request.py new file mode 100644 index 00000000000..9fc12235130 --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/stream_x_fern_streaming_union_request.py @@ -0,0 +1,88 @@ +# This file was auto-generated by Fern from our API Definition. + +from __future__ import annotations + +import typing + +import pydantic +import typing_extensions +from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel + + +class Base(UniversalBaseModel): + stream_response: typing.Literal[False] = False + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +class StreamXFernStreamingUnionRequest_Message(Base): + """ + A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + """ + + type: typing.Literal["message"] = "message" + message: str + prompt: str + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +class StreamXFernStreamingUnionRequest_Interrupt(Base): + """ + A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + """ + + type: typing.Literal["interrupt"] = "interrupt" + prompt: str + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +class StreamXFernStreamingUnionRequest_Compact(Base): + """ + A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + """ + + type: typing.Literal["compact"] = "compact" + data: str + prompt: str + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +StreamXFernStreamingUnionRequest = typing_extensions.Annotated[ + typing.Union[ + StreamXFernStreamingUnionRequest_Message, + StreamXFernStreamingUnionRequest_Interrupt, + StreamXFernStreamingUnionRequest_Compact, + ], + pydantic.Field(discriminator="type"), +] diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/stream_x_fern_streaming_union_stream_request.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/stream_x_fern_streaming_union_stream_request.py new file mode 100644 index 00000000000..36c55955394 --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/stream_x_fern_streaming_union_stream_request.py @@ -0,0 +1,88 @@ +# This file was auto-generated by Fern from our API Definition. + +from __future__ import annotations + +import typing + +import pydantic +import typing_extensions +from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel + + +class Base(UniversalBaseModel): + stream_response: typing.Literal[True] = True + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +class StreamXFernStreamingUnionStreamRequest_Message(Base): + """ + A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + """ + + type: typing.Literal["message"] = "message" + message: str + prompt: str + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +class StreamXFernStreamingUnionStreamRequest_Interrupt(Base): + """ + A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + """ + + type: typing.Literal["interrupt"] = "interrupt" + prompt: str + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +class StreamXFernStreamingUnionStreamRequest_Compact(Base): + """ + A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + """ + + type: typing.Literal["compact"] = "compact" + data: str + prompt: str + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +StreamXFernStreamingUnionStreamRequest = typing_extensions.Annotated[ + typing.Union[ + StreamXFernStreamingUnionStreamRequest_Message, + StreamXFernStreamingUnionStreamRequest_Interrupt, + StreamXFernStreamingUnionStreamRequest_Compact, + ], + pydantic.Field(discriminator="type"), +] diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_compact_variant.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_compact_variant.py new file mode 100644 index 00000000000..f1e6f57038a --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_compact_variant.py @@ -0,0 +1,27 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +import pydantic +from ..core.pydantic_utilities import IS_PYDANTIC_V2 +from .union_stream_request_base import UnionStreamRequestBase + + +class UnionStreamCompactVariant(UnionStreamRequestBase): + """ + Requests compaction of history. Inherits stream_response from base and adds compact-specific fields. + """ + + data: str = pydantic.Field() + """ + Compact data payload. + """ + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_interrupt_variant.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_interrupt_variant.py new file mode 100644 index 00000000000..d5ef627adb8 --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_interrupt_variant.py @@ -0,0 +1,22 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +import pydantic +from ..core.pydantic_utilities import IS_PYDANTIC_V2 +from .union_stream_request_base import UnionStreamRequestBase + + +class UnionStreamInterruptVariant(UnionStreamRequestBase): + """ + Cancels the current operation. Inherits stream_response from base. + """ + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_message_variant.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_message_variant.py new file mode 100644 index 00000000000..1324f8395de --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_message_variant.py @@ -0,0 +1,27 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +import pydantic +from ..core.pydantic_utilities import IS_PYDANTIC_V2 +from .union_stream_request_base import UnionStreamRequestBase + + +class UnionStreamMessageVariant(UnionStreamRequestBase): + """ + A user input message. Inherits stream_response from base via allOf. + """ + + message: str = pydantic.Field() + """ + The message content. + """ + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_request.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_request.py new file mode 100644 index 00000000000..f1f80404369 --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_request.py @@ -0,0 +1,74 @@ +# This file was auto-generated by Fern from our API Definition. + +from __future__ import annotations + +import typing + +import pydantic +import typing_extensions +from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel + + +class UnionStreamRequest_Message(UniversalBaseModel): + """ + A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + """ + + type: typing.Literal["message"] = "message" + message: str + stream_response: typing.Optional[bool] = None + prompt: str + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +class UnionStreamRequest_Interrupt(UniversalBaseModel): + """ + A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + """ + + type: typing.Literal["interrupt"] = "interrupt" + stream_response: typing.Optional[bool] = None + prompt: str + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +class UnionStreamRequest_Compact(UniversalBaseModel): + """ + A discriminated union request matching the Vectara pattern (FER-9556). Each variant inherits stream_response from UnionStreamRequestBase via allOf. The importer pins stream_response to Literal[True/False] at this union level, but the allOf inheritance re-introduces it as boolean in each variant, causing the type conflict. + """ + + type: typing.Literal["compact"] = "compact" + data: str + stream_response: typing.Optional[bool] = None + prompt: str + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow + + +UnionStreamRequest = typing_extensions.Annotated[ + typing.Union[UnionStreamRequest_Message, UnionStreamRequest_Interrupt, UnionStreamRequest_Compact], + pydantic.Field(discriminator="type"), +] diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_request_base.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_request_base.py new file mode 100644 index 00000000000..bafff3f811f --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/union_stream_request_base.py @@ -0,0 +1,31 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +import pydantic +from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel + + +class UnionStreamRequestBase(UniversalBaseModel): + """ + Base schema for union stream requests. Contains the stream_response field that is inherited by all oneOf variants via allOf. This schema is also referenced directly by a non-streaming endpoint to ensure it is not excluded from the context. + """ + + stream_response: typing.Optional[bool] = pydantic.Field(default=None) + """ + Whether to stream the response. + """ + + prompt: str = pydantic.Field() + """ + The input prompt. + """ + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/validate_union_request_response.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/validate_union_request_response.py new file mode 100644 index 00000000000..51ceedd79cc --- /dev/null +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/src/seed/types/validate_union_request_response.py @@ -0,0 +1,19 @@ +# This file was auto-generated by Fern from our API Definition. + +import typing + +import pydantic +from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel + + +class ValidateUnionRequestResponse(UniversalBaseModel): + valid: typing.Optional[bool] = None + + if IS_PYDANTIC_V2: + model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 + else: + + class Config: + frozen = True + smart_union = True + extra = pydantic.Extra.allow diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/tests/wire/test_.py b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/tests/wire/test_.py index bd988de04a7..d6c2a08abf8 100644 --- a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/tests/wire/test_.py +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/tests/wire/test_.py @@ -1,5 +1,7 @@ from .conftest import get_client, verify_request_count +from seed import StreamXFernStreamingUnionRequest_Message, StreamXFernStreamingUnionStreamRequest_Message + def test__stream_protocol_no_collision() -> None: """Test streamProtocolNoCollision endpoint with WireMock""" @@ -62,3 +64,127 @@ def test__stream_oas_spec_native() -> None: for _ in client.stream_oas_spec_native(): pass verify_request_count(test_id, "POST", "/stream/oas-spec-native", None, 1) + + +def test__stream_x_fern_streaming_condition_stream() -> None: + """Test streamXFernStreamingCondition_stream endpoint with WireMock""" + test_id = "stream_x_fern_streaming_condition_stream.0" + client = get_client(test_id) + for _ in client.stream_x_fern_streaming_condition_stream( + query="query", + ): + pass + verify_request_count(test_id, "POST", "/stream/x-fern-streaming-condition", None, 1) + + +def test__stream_x_fern_streaming_condition() -> None: + """Test streamXFernStreamingCondition endpoint with WireMock""" + test_id = "stream_x_fern_streaming_condition.0" + client = get_client(test_id) + client.stream_x_fern_streaming_condition( + query="query", + ) + verify_request_count(test_id, "POST", "/stream/x-fern-streaming-condition", None, 1) + + +def test__stream_x_fern_streaming_shared_schema_stream() -> None: + """Test streamXFernStreamingSharedSchema_stream endpoint with WireMock""" + test_id = "stream_x_fern_streaming_shared_schema_stream.0" + client = get_client(test_id) + for _ in client.stream_x_fern_streaming_shared_schema_stream( + prompt="prompt", + model="model", + ): + pass + verify_request_count(test_id, "POST", "/stream/x-fern-streaming-shared-schema", None, 1) + + +def test__stream_x_fern_streaming_shared_schema() -> None: + """Test streamXFernStreamingSharedSchema endpoint with WireMock""" + test_id = "stream_x_fern_streaming_shared_schema.0" + client = get_client(test_id) + client.stream_x_fern_streaming_shared_schema( + prompt="prompt", + model="model", + ) + verify_request_count(test_id, "POST", "/stream/x-fern-streaming-shared-schema", None, 1) + + +def test__validate_completion() -> None: + """Test validateCompletion endpoint with WireMock""" + test_id = "validate_completion.0" + client = get_client(test_id) + client.validate_completion( + prompt="prompt", + model="model", + ) + verify_request_count(test_id, "POST", "/validate-completion", None, 1) + + +def test__stream_x_fern_streaming_union_stream() -> None: + """Test streamXFernStreamingUnion_stream endpoint with WireMock""" + test_id = "stream_x_fern_streaming_union_stream.0" + client = get_client(test_id) + for _ in client.stream_x_fern_streaming_union_stream( + request=StreamXFernStreamingUnionStreamRequest_Message( + stream_response=True, + prompt="prompt", + message="message", + ), + ): + pass + verify_request_count(test_id, "POST", "/stream/x-fern-streaming-union", None, 1) + + +def test__stream_x_fern_streaming_union() -> None: + """Test streamXFernStreamingUnion endpoint with WireMock""" + test_id = "stream_x_fern_streaming_union.0" + client = get_client(test_id) + client.stream_x_fern_streaming_union( + request=StreamXFernStreamingUnionRequest_Message( + stream_response=False, + prompt="prompt", + message="message", + ), + ) + verify_request_count(test_id, "POST", "/stream/x-fern-streaming-union", None, 1) + + +def test__validate_union_request() -> None: + """Test validateUnionRequest endpoint with WireMock""" + test_id = "validate_union_request.0" + client = get_client(test_id) + client.validate_union_request( + prompt="prompt", + ) + verify_request_count(test_id, "POST", "/validate-union-request", None, 1) + + +def test__stream_x_fern_streaming_nullable_condition_stream() -> None: + """Test streamXFernStreamingNullableCondition_stream endpoint with WireMock""" + test_id = "stream_x_fern_streaming_nullable_condition_stream.0" + client = get_client(test_id) + for _ in client.stream_x_fern_streaming_nullable_condition_stream( + query="query", + ): + pass + verify_request_count(test_id, "POST", "/stream/x-fern-streaming-nullable-condition", None, 1) + + +def test__stream_x_fern_streaming_nullable_condition() -> None: + """Test streamXFernStreamingNullableCondition endpoint with WireMock""" + test_id = "stream_x_fern_streaming_nullable_condition.0" + client = get_client(test_id) + client.stream_x_fern_streaming_nullable_condition( + query="query", + ) + verify_request_count(test_id, "POST", "/stream/x-fern-streaming-nullable-condition", None, 1) + + +def test__stream_x_fern_streaming_sse_only() -> None: + """Test streamXFernStreamingSseOnly endpoint with WireMock""" + test_id = "stream_x_fern_streaming_sse_only.0" + client = get_client(test_id) + for _ in client.stream_x_fern_streaming_sse_only(): + pass + verify_request_count(test_id, "POST", "/stream/x-fern-streaming-sse-only", None, 1) diff --git a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/wiremock/wiremock-mappings.json b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/wiremock/wiremock-mappings.json index 796ca787dc6..21f18734e03 100644 --- a/seed/python-sdk/server-sent-events-openapi/with-wire-tests/wiremock/wiremock-mappings.json +++ b/seed/python-sdk/server-sent-events-openapi/with-wire-tests/wiremock/wiremock-mappings.json @@ -181,9 +181,295 @@ } } } + }, + { + "id": "a92674bc-618d-43b5-a4b8-ee4724d69afd", + "name": "x-fern-streaming with stream-condition and $ref request body - default", + "request": { + "urlPathTemplate": "/stream/x-fern-streaming-condition", + "method": "POST" + }, + "response": { + "status": 200, + "body": "\"\"", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "a92674bc-618d-43b5-a4b8-ee4724d69afd", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "c4399573-7257-4afa-9a26-c13c862f7f44", + "name": "x-fern-streaming with stream-condition and $ref request body - default", + "request": { + "urlPathTemplate": "/stream/x-fern-streaming-condition", + "method": "POST" + }, + "response": { + "status": 200, + "body": "{\n \"answer\": \"answer\",\n \"finishReason\": \"complete\"\n}", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "c4399573-7257-4afa-9a26-c13c862f7f44", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "56fc9590-ba61-4747-bd46-f04be1269f11", + "name": "x-fern-streaming with shared request schema - default", + "request": { + "urlPathTemplate": "/stream/x-fern-streaming-shared-schema", + "method": "POST" + }, + "response": { + "status": 200, + "body": "\"\"", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "56fc9590-ba61-4747-bd46-f04be1269f11", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "320847df-8c7b-42b5-b97e-2237c36bbfa5", + "name": "x-fern-streaming with shared request schema - default", + "request": { + "urlPathTemplate": "/stream/x-fern-streaming-shared-schema", + "method": "POST" + }, + "response": { + "status": 200, + "body": "{\n \"answer\": \"answer\",\n \"finishReason\": \"complete\"\n}", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "320847df-8c7b-42b5-b97e-2237c36bbfa5", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "99e09f9c-44a7-40c2-9b71-c7b58c309670", + "name": "Non-streaming endpoint sharing request schema with endpoint 10 - default", + "request": { + "urlPathTemplate": "/validate-completion", + "method": "POST" + }, + "response": { + "status": 200, + "body": "{\n \"answer\": \"answer\",\n \"finishReason\": \"complete\"\n}", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "99e09f9c-44a7-40c2-9b71-c7b58c309670", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "6403c880-9bb6-4af4-96df-cf5125abf22a", + "name": "x-fern-streaming with discriminated union request body - default", + "request": { + "urlPathTemplate": "/stream/x-fern-streaming-union", + "method": "POST" + }, + "response": { + "status": 200, + "body": "\"\"", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "6403c880-9bb6-4af4-96df-cf5125abf22a", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "8831acea-84dc-48da-9aca-477729d64cec", + "name": "x-fern-streaming with discriminated union request body - default", + "request": { + "urlPathTemplate": "/stream/x-fern-streaming-union", + "method": "POST" + }, + "response": { + "status": 200, + "body": "{\n \"answer\": \"answer\",\n \"finishReason\": \"complete\"\n}", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "8831acea-84dc-48da-9aca-477729d64cec", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "97d9037b-42ab-4e79-ad59-583bfa3a6138", + "name": "Non-streaming endpoint referencing the union base schema - default", + "request": { + "urlPathTemplate": "/validate-union-request", + "method": "POST" + }, + "response": { + "status": 200, + "body": "{\n \"valid\": true\n}", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "97d9037b-42ab-4e79-ad59-583bfa3a6138", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "1983a87e-800d-48d1-9596-4ddca4dc6b65", + "name": "x-fern-streaming with nullable stream condition field - default", + "request": { + "urlPathTemplate": "/stream/x-fern-streaming-nullable-condition", + "method": "POST" + }, + "response": { + "status": 200, + "body": "\"\"", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "1983a87e-800d-48d1-9596-4ddca4dc6b65", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "1e1675a0-7b8a-4ce5-ab4a-2a3a1a04b162", + "name": "x-fern-streaming with nullable stream condition field - default", + "request": { + "urlPathTemplate": "/stream/x-fern-streaming-nullable-condition", + "method": "POST" + }, + "response": { + "status": 200, + "body": "{\n \"answer\": \"answer\",\n \"finishReason\": \"complete\"\n}", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "1e1675a0-7b8a-4ce5-ab4a-2a3a1a04b162", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "6c0b88de-5271-4c14-b4e1-865445d0f99f", + "name": "x-fern-streaming with SSE format but no stream-condition - default", + "request": { + "urlPathTemplate": "/stream/x-fern-streaming-sse-only", + "method": "POST" + }, + "response": { + "status": 200, + "body": "event: message\ndata: \"string\"\n", + "headers": { + "Content-Type": "text/event-stream" + } + }, + "uuid": "6c0b88de-5271-4c14-b4e1-865445d0f99f", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } } ], "meta": { - "total": 7 + "total": 18 } } \ No newline at end of file diff --git a/test-definitions/fern/apis/server-sent-events-openapi/openapi.yml b/test-definitions/fern/apis/server-sent-events-openapi/openapi.yml index 403fd9e58c6..c3891be67a8 100644 --- a/test-definitions/fern/apis/server-sent-events-openapi/openapi.yml +++ b/test-definitions/fern/apis/server-sent-events-openapi/openapi.yml @@ -27,6 +27,43 @@ info: Endpoint 7 tests the OAS 3.2 spec-native pattern: inline oneOf variants extending a base Event schema, using const on event fields and contentSchema/contentMediaType on data fields. No discriminator object. + + Endpoints 8-13 test x-fern-streaming extension patterns. These use the + Fern-specific x-fern-streaming extension to express streaming endpoints in + OpenAPI, with various request body shapes and stream-condition patterns. + + Endpoint 8 tests x-fern-streaming with stream-condition and a $ref request + body. The stream-condition field on the request determines whether the + response is streamed (SSE) or returned as a single JSON response. + + Endpoint 9 tests x-fern-streaming with stream-condition where the $ref + request schema has x-fern-type-name set, which previously caused name + collisions between streaming and non-streaming request wrapper names. + + Endpoint 10 tests x-fern-streaming with a shared request schema that is + also referenced by a non-streaming endpoint (endpoint 11). This ensures the + shared schema is not excluded from the context during streaming processing. + + Endpoint 11 is a non-streaming endpoint that shares its request schema with + endpoint 10, validating that shared $ref schemas remain available. + + Endpoint 12 tests x-fern-streaming with stream-condition where the request + body is a discriminated union (oneOf) whose variants inherit the stream + condition field from a shared base schema via allOf. This directly + reproduces the Vectara regression (FER-9556) where the importer pins + stream_response to Literal[True/False] at the union level, but each + variant independently inherits stream_response: boolean from the base + via allOf, causing a type conflict. Three variants are tested to match + the real-world pattern. + + Endpoint 13 tests x-fern-streaming with stream-condition where the + stream condition field is nullable (type: ["boolean", "null"] in OAS 3.1). + This reproduces the spread-order bug from PR #13605 where the nullable type + array would overwrite the const literal, producing stream?: true | null + instead of stream: true. + + Endpoint 14 tests x-fern-streaming with format: sse but no stream-condition, + representing a stream-only endpoint with explicit SSE format marking. version: "0.1.0" paths: @@ -286,6 +323,251 @@ paths: contentSchema: $ref: "#/components/schemas/StatusPayload" + # ========================================================================== + # Endpoints 8-9: x-fern-streaming with stream-condition + # ========================================================================== + /stream/x-fern-streaming-condition: + post: + operationId: streamXFernStreamingCondition + summary: x-fern-streaming with stream-condition and $ref request body + description: > + Uses x-fern-streaming extension with stream-condition to split into + streaming and non-streaming variants based on a request body field. + The request body is a $ref to a named schema. The response and + response-stream point to different schemas. + x-fern-streaming: + stream-condition: $request.stream + response: + $ref: "#/components/schemas/CompletionFullResponse" + response-stream: + $ref: "#/components/schemas/CompletionStreamChunk" + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/CompletionRequest" + responses: + "200": + description: A completion response (full or streamed) + content: + application/json: + schema: + $ref: "#/components/schemas/CompletionFullResponse" + text/event-stream: + schema: + $ref: "#/components/schemas/CompletionStreamChunk" + + # Endpoint 9 commented out — causes ChatCompletionRequest name collision + # that blocks IR generation for the entire fixture. Uncomment to test the + # x-fern-type-name disambiguation fix (PR #14256) in isolation. + # + # /stream/x-fern-streaming-type-name: + # post: + # operationId: streamXFernStreamingTypeName + # summary: x-fern-streaming with stream-condition and x-fern-type-name on request schema + # description: > + # Same pattern as endpoint 8, but the request schema has x-fern-type-name + # set. This previously caused both streaming and non-streaming request + # wrapper variants to inherit the same nameOverride, leading to duplicate + # declaration errors. The auto-disambiguation logic now detects + # x-fern-type-name and appends "Streaming" to the streaming variant. + # x-fern-streaming: + # stream-condition: $request.stream + # response: + # $ref: "#/components/schemas/CompletionFullResponse" + # response-stream: + # $ref: "#/components/schemas/CompletionStreamChunk" + # requestBody: + # required: true + # content: + # application/json: + # schema: + # $ref: "#/components/schemas/ChatCompletionRequest" + # responses: + # "200": + # description: A chat completion response + # content: + # application/json: + # schema: + # $ref: "#/components/schemas/CompletionFullResponse" + + # ========================================================================== + # Endpoints 10-11: Shared request schema across streaming and non-streaming + # ========================================================================== + /stream/x-fern-streaming-shared-schema: + post: + operationId: streamXFernStreamingSharedSchema + summary: x-fern-streaming with shared request schema + description: > + Uses x-fern-streaming with stream-condition. The request body $ref + (SharedCompletionRequest) is also referenced by a separate non-streaming + endpoint (/validate-completion). This tests that the shared request + schema is not excluded from the context during streaming processing. + x-fern-streaming: + stream-condition: $request.stream + response: + $ref: "#/components/schemas/CompletionFullResponse" + response-stream: + $ref: "#/components/schemas/CompletionStreamChunk" + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/SharedCompletionRequest" + responses: + "200": + description: A completion response + content: + application/json: + schema: + $ref: "#/components/schemas/CompletionFullResponse" + + /validate-completion: + post: + operationId: validateCompletion + summary: Non-streaming endpoint sharing request schema with endpoint 10 + description: > + A non-streaming endpoint that references the same SharedCompletionRequest + schema as endpoint 10. Ensures the shared $ref schema remains available + and is not excluded during the streaming endpoint's processing. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/SharedCompletionRequest" + responses: + "200": + description: Validation result + content: + application/json: + schema: + $ref: "#/components/schemas/CompletionFullResponse" + + # ========================================================================== + # Endpoint 12: x-fern-streaming with discriminated union request body + # ========================================================================== + /stream/x-fern-streaming-union: + post: + operationId: streamXFernStreamingUnion + summary: x-fern-streaming with discriminated union request body + description: > + Uses x-fern-streaming with stream-condition where the request body is a + discriminated union (oneOf) whose variants inherit the stream condition + field (stream_response) from a shared base schema via allOf. Tests that + the stream condition property is not duplicated in the generated output + when the base schema is expanded into each variant. + x-fern-streaming: + stream-condition: $request.stream_response + response: + $ref: "#/components/schemas/CompletionFullResponse" + response-stream: + $ref: "#/components/schemas/CompletionStreamChunk" + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/UnionStreamRequest" + responses: + "200": + description: A completion response + content: + application/json: + schema: + $ref: "#/components/schemas/CompletionFullResponse" + text/event-stream: + schema: + $ref: "#/components/schemas/CompletionStreamChunk" + + /validate-union-request: + post: + operationId: validateUnionRequest + summary: Non-streaming endpoint referencing the union base schema + description: > + References UnionStreamRequestBase directly, ensuring the base schema + cannot be excluded from the context. This endpoint exists to verify + that shared base schemas used in discriminated union variants with + stream-condition remain available. + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/UnionStreamRequestBase" + responses: + "200": + description: Validation result + content: + application/json: + schema: + type: object + properties: + valid: + type: boolean + + # ========================================================================== + # Endpoint 13: x-fern-streaming with nullable stream-condition field + # ========================================================================== + /stream/x-fern-streaming-nullable-condition: + post: + operationId: streamXFernStreamingNullableCondition + summary: x-fern-streaming with nullable stream condition field + description: > + Uses x-fern-streaming with stream-condition where the stream field is + nullable (type: ["boolean", "null"] in OAS 3.1). Previously, the spread + order in the importer caused the nullable type array to overwrite the + const literal, producing stream?: true | null instead of stream: true. + The const/type override must be spread after the original property. + x-fern-streaming: + stream-condition: $request.stream + response: + $ref: "#/components/schemas/CompletionFullResponse" + response-stream: + $ref: "#/components/schemas/CompletionStreamChunk" + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/NullableStreamRequest" + responses: + "200": + description: A completion response + content: + application/json: + schema: + $ref: "#/components/schemas/CompletionFullResponse" + + # ========================================================================== + # Endpoint 14: x-fern-streaming with SSE format only (no stream-condition) + # ========================================================================== + /stream/x-fern-streaming-sse-only: + post: + operationId: streamXFernStreamingSseOnly + summary: x-fern-streaming with SSE format but no stream-condition + description: > + Uses x-fern-streaming with format: sse but no stream-condition. This + represents a stream-only endpoint that always returns SSE. There is no + non-streaming variant, and the response is always a stream of chunks. + x-fern-streaming: + format: sse + requestBody: + required: true + content: + application/json: + schema: + $ref: "#/components/schemas/StreamRequest" + responses: + "200": + description: SSE stream of completion chunks + content: + application/json: + schema: + type: string + components: schemas: StreamRequest: @@ -458,3 +740,185 @@ components: type: string enum: - entity + + # ========================================================================== + # x-fern-streaming request/response schemas (endpoints 8-13) + # ========================================================================== + + # -- Endpoint 8: Basic stream-condition request + CompletionRequest: + type: object + properties: + query: + type: string + description: The prompt or query to complete. + stream: + type: boolean + description: Whether to stream the response. + default: false + required: + - query + + # -- Endpoint 13: Nullable stream condition field + NullableStreamRequest: + type: object + properties: + query: + type: string + description: The prompt or query to complete. + stream: + type: + - boolean + - "null" + description: > + Whether to stream the response. This field is nullable (OAS 3.1 + type array), which previously caused the const literal to be + overwritten by the nullable type during spread in the importer. + default: false + required: + - query + + # -- Endpoint 9: stream-condition with x-fern-type-name (commented out) + # ChatCompletionRequest: + # type: object + # properties: + # message: + # type: string + # description: The user's chat message. + # stream: + # type: boolean + # description: Whether to stream the response. + # required: + # - message + # x-fern-type-name: ChatCompletionRequest + + # -- Endpoints 10-11: Shared request schema + SharedCompletionRequest: + type: object + properties: + prompt: + type: string + description: The prompt to complete. + model: + type: string + description: The model to use. + stream: + type: boolean + description: Whether to stream the response. + required: + - prompt + - model + + # -- Shared streaming response schemas + CompletionFullResponse: + type: object + description: Full response returned when streaming is disabled. + properties: + answer: + type: string + description: The complete generated answer. + finishReason: + type: string + description: Why generation stopped. + enum: + - complete + - length + - error + + CompletionStreamChunk: + type: object + description: A single chunk in a streamed completion response. + properties: + delta: + type: string + description: The incremental text chunk. + tokens: + type: integer + description: Number of tokens in this chunk. + + # -- Endpoint 12: Discriminated union request body with stream-condition + UnionStreamRequestBase: + type: object + description: > + Base schema for union stream requests. Contains the stream_response field + that is inherited by all oneOf variants via allOf. This schema is also + referenced directly by a non-streaming endpoint to ensure it is not + excluded from the context. + properties: + stream_response: + type: boolean + description: Whether to stream the response. + default: false + prompt: + type: string + description: The input prompt. + required: + - prompt + + UnionStreamMessageVariant: + description: A user input message. Inherits stream_response from base via allOf. + allOf: + - $ref: "#/components/schemas/UnionStreamRequestBase" + - type: object + properties: + type: + type: string + default: message + message: + type: string + description: The message content. + required: + - type + - message + + UnionStreamInterruptVariant: + description: Cancels the current operation. Inherits stream_response from base. + allOf: + - $ref: "#/components/schemas/UnionStreamRequestBase" + - type: object + properties: + type: + type: string + default: interrupt + required: + - type + + UnionStreamCompactVariant: + description: > + Requests compaction of history. Inherits stream_response from base + and adds compact-specific fields. + allOf: + - $ref: "#/components/schemas/UnionStreamRequestBase" + - type: object + properties: + type: + type: string + default: compact + data: + type: string + description: Compact data payload. + required: + - type + - data + + UnionStreamRequest: + description: > + A discriminated union request matching the Vectara pattern (FER-9556). + Each variant inherits stream_response from UnionStreamRequestBase via + allOf. The importer pins stream_response to Literal[True/False] at this + union level, but the allOf inheritance re-introduces it as boolean in + each variant, causing the type conflict. + properties: + type: + type: string + default: message + discriminator: + propertyName: type + mapping: + message: "#/components/schemas/UnionStreamMessageVariant" + interrupt: "#/components/schemas/UnionStreamInterruptVariant" + compact: "#/components/schemas/UnionStreamCompactVariant" + oneOf: + - $ref: "#/components/schemas/UnionStreamMessageVariant" + - $ref: "#/components/schemas/UnionStreamInterruptVariant" + - $ref: "#/components/schemas/UnionStreamCompactVariant"