> ## Documentation Index
> Fetch the complete documentation index at: https://phaseo.app/docs/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Phaseo Gateway base URL: https://api.phaseo.app/v1. Send `Authorization: Bearer $PHASEO_API_KEY` with every request.
> Model IDs look like `provider/model`, for example `openai/gpt-6-astra`. Do not guess IDs: list them with `GET /v1/models` or check https://phaseo.app/models. `phaseo/free` routes to an available free model and needs no wallet balance.
> For new text integrations prefer `POST /v1/responses`. `POST /v1/chat/completions` (OpenAI format) and `POST /v1/messages` (Anthropic format) suit existing code.
> The full API contract is https://phaseo.app/docs/openapi/v1/openapi.yaml. Official SDKs: `@phaseo/sdk` (TypeScript) and `phaseo` (Python), plus Go, C#, PHP, Ruby and Rust.
> Search these docs over MCP at https://phaseo.app/docs/mcp, and install Phaseo skills with `npx skills add https://phaseo.app/docs`. If a page is wrong or out of date, report it with the MCP `submit_feedback` tool.
> Manage Phaseo accounts with the `phaseo` CLI (`npm install -g @phaseo/cli`, then `phaseo login` or `phaseo login --device-code`), the `/v1` Management API or the MCP server at `https://mcp.phaseo.app/mcp?access=manage`. Do not send users to the dashboard for account tasks. A person is still needed for sign-up, approving a sign-in, paying the first top-up on the checkout link that `phaseo credits add` returns when no card is saved, confirming each saved-card top-up from the emailed link, and account security (password, MFA, passkeys). Create API keys with `phaseo keys create --name <name> --json`; never guess one. Credit top-ups need `phaseo login --scopes billing:write` first. Task map: https://phaseo.app/docs/v1/developers/manage-from-an-agent.md.

# Streaming del Agent SDK

> Muestra el texto, el razonamiento y la actividad de herramientas de un agente mientras la ejecución está en curso.

Llama al método de streaming del agente en lugar de al de ejecución para mostrar el texto y la actividad de herramientas mientras la ejecución está en curso. Ejecuta el mismo bucle reanudable sobre el stream SSE de Responses del gateway, y el método de continuación con streaming hace lo mismo para una ejecución en pausa. Rust no tiene streaming.

## Haz streaming de texto

```typescript TypeScript theme={null}
const result = agent.stream({ input, client });

for await (const delta of result.getTextStream()) {
  process.stdout.write(delta);
}

const completed = await result.getResult();
console.log(completed.run.status);
```

```python Python theme={null}
stream = agent.stream(input="Research this topic", client=client)

for delta in stream.text_stream():
    print(delta, end="", flush=True)

completed = stream.result()
```

```go Go theme={null}
stream := agent.Stream(ctx, phaseoagent.RunOptions{Input: input, Client: client})

for delta := range stream.Text() {
  fmt.Print(delta)
}

completed, err := stream.Result()
```

```csharp C# theme={null}
var stream = agent.Stream(new RunOptions { Input = input, Client = client });

await foreach (var delta in stream.TextStream())
{
    Console.Write(delta);
}

var completed = await stream.GetResult();
```

```php PHP theme={null}
$stream = $agent->stream(input: $input, client: $client);

foreach ($stream->textStream() as $delta) {
    echo $delta;
}

$completed = $stream->getResult();
```

```ruby Ruby theme={null}
stream = agent.stream(input: "Research this topic", client: client)

stream.text_stream.each { |delta| print delta }

completed = stream.result
```

```java Java theme={null}
// textStream() bloquea hasta que termina la ejecución; imprime los deltas en directo desde onEvent.
var options = new AgentSdk.RunOptions(
    input, AgentSdk.createGatewayAgentClient(), null, null, null, null, null, null,
    event -> {
        if (event.type().equals("response.output_text.delta")) {
            System.out.print(event.details().get("delta"));
        }
    },
    null);
var completed = agent.stream(options).getResult();
```

El resultado final es el mismo resultado de ejecución que devuelve el método de ejecución. Cómo funciona el stream depende del lenguaje:

> [tab] TypeScript
>
> `agent.stream()` y `agent.continueStream()` devuelven un resultado de stream de inmediato. `getResult()` se resuelve cuando termina la ejecución.

> [tab] Python
>
> `agent.stream(...)` y `agent.continue_stream(...)` ejecutan el bucle en un hilo en segundo plano y devuelven un `AgentStreamResult` reproducible. `result()` espera a la ejecución.

> [tab] Go
>
> `agent.Stream` y `agent.ContinueStream` inician la ejecución en una goroutine y devuelven un `*StreamResult` de inmediato. `Result()` bloquea hasta que termina la ejecución.

> [tab] C#
>
> `agent.Stream` y `agent.ContinueStream` inician la ejecución y devuelven un `AgentStreamResult` de inmediato. `GetResult()` se completa cuando termina la ejecución.

> [tab] PHP
>
> `$agent->stream()` y `$agent->continueStream()` devuelven un `AgentStreamResult`. PHP no tiene hilo en segundo plano: la ejecución avanza dentro de una Fiber solo mientras tu código pide el siguiente evento, y `getResult()` consume los eventos que quedan. Eso encaja con scripts de CLI y workers de solicitudes; para una interfaz en directo, itera dentro de la solicitud que sirve la respuesta, o ejecuta el agente en un worker y envía tú los eventos al navegador.
>
> `stream()` solo recibe `input`, `client`, `context` y `state`; usa `run()` para las demás opciones.

> [tab] Ruby
>
> `agent.stream` y `agent.continue_stream` inician la ejecución en un hilo de trabajo y devuelven un `StreamResult` de inmediato. `result` espera a que termine el hilo, vuelve a lanzar cualquier error y devuelve el resultado de la ejecución.
>
> `stream` solo recibe `input:`, `client:`, `context:` y `state:`; usa `run` para las demás opciones.

> [tab] Java
>
> `agent.stream` y `agent.continueStream` inician la ejecución en un hilo daemon llamado `phaseo-agent-stream` y devuelven un `StreamResult` de inmediato. `textStream()` y `fullStream()` devuelven listas y bloquean hasta que termina la ejecución, así que un bucle sobre `textStream()` imprime la respuesta completa al final. Para actuar sobre los eventos mientras la ejecución está en marcha, pasa un consumidor `onEvent` en `RunOptions`, como arriba.

> [tab] Rust
>
> `phaseo-agent` 0.2 no tiene streaming. Llama a `run_with_events` o `continue_with_events` para recibir los eventos del ciclo de vida mediante un callback, y lee el texto en la ejecución completada.

## Elige un stream

Cada consumidor reproduce los eventos desde el principio, así que el código que muestra la interfaz, el de registro y el de persistencia pueden leer la misma ejecución sin una segunda solicitud al modelo.

| Produce | TypeScript | Python | Go | C# | PHP | Ruby | Java |
| - | - | - | - | - | - | - | - |
| Deltas del texto de la respuesta | `getTextStream()` | `text_stream()` | `Text()` | `TextStream()` | `textStream()` | `text_stream` | `textStream()` (lista) |
| Deltas de razonamiento | `getReasoningStream()` | `reasoning_stream()` | `Events()`, con filtro | `FullStream()`, con filtro | `reasoningStream()` | `reasoning_stream` | `fullStream()`, con filtro |
| Elementos de la línea de tiempo | `getItemsStream()` (tipados) | `item_stream()` (dicts) | `Events()`, con filtro | `FullStream()`, con filtro | `itemStream()` | `item_stream` | `fullStream()`, con filtro |
| Eventos del ciclo de vida de herramientas | `getToolStream()` | `tool_stream()` | `Events()`, con filtro | `FullStream()`, con filtro | `fullStream()`, con filtro | `full_stream`, con filtro | `fullStream()`, con filtro |
| Todos los eventos | `getFullStream()` y después un evento `result` final | `full_stream()` | `Events()` (canal) | `FullStream()` (`IAsyncEnumerable`) | `fullStream()` | `full_stream` (`Enumerator`) | `fullStream()` (lista, tras la ejecución) |

TypeScript también tiene `getText()` para esperar la respuesta completa, de modo que la visualización y la persistencia pueden ejecutarse en paralelo:

```typescript theme={null}
const result = agent.stream({ input, client });

const [text, completed] = await Promise.all([
  result.getText(),
  result.getResult(),
]);
```

Los eventos del modelo son `response.output_text.delta`, `response.reasoning.delta` y `response.item`; en [Elementos](https://phaseo.app/docs/es/v1/sdk-reference/agent/items.md) están sus campos. Los eventos del modelo solo se envían en streaming cuando el cliente admite streaming, como hacen todos los clientes de gateway. Con otro cliente del modelo (uno que no implemente `StreamingModelClient` o `IStreamingModelClient`, ni responda a `stream`), el stream sigue emitiendo eventos del ciclo de vida, pero no deltas de texto.

## Haz streaming del progreso de las herramientas

Las herramientas que informan de su progreso publican eventos `tool.preliminary_result`, que aparecen en el stream completo (y en el stream de herramientas de TypeScript) y quedan asociados al paso completado. En [Herramientas](https://phaseo.app/docs/es/v1/sdk-reference/agent/tools.md#report-progress-and-update-context) se muestra cómo informa del progreso cada lenguaje.

## Cancela un stream

| Lenguaje | Llamada | Qué pasa |
| - | - | - |
| TypeScript | `cancel()` | Aborta la ejecución. Las herramientas locales reciben la cancelación mediante `context.signal`. |
| Python | `cancel()` | Cierra la solicitud activa al modelo; la ejecución lanza `InterruptedError` |
| Go | `stream.Cancel()` | Cancela el contexto que se pasó a la ejecución, lo que detiene la solicitud al modelo; `Result()` devuelve un error |
| C# | `stream.Cancel()`, o cancela `RunOptions.CancellationToken` | Cancela un token vinculado que llega a la solicitud al modelo y al `runtime.CancellationToken` de cada herramienta; `GetResult()` lanza una excepción |
| PHP | `$stream->cancel()` | Lanza `Agent stream cancelled` dentro de la Fiber, lo que detiene la ejecución en su siguiente punto de suspensión |
| Ruby | `stream.cancel` | Mata el hilo de trabajo, lo que cierra el stream HTTP y termina todos los enumeradores |
| Java | `stream.cancel()` | Interrumpe el hilo de trabajo y la lectura HTTP, y cancela el future del resultado; `getResult()` lanza una excepción |
| Rust | No disponible | Las ejecuciones son síncronas |

Cada paso completado conserva su ID de solicitud, el proveedor, el modelo, el motivo de finalización, las advertencias y el uso.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.