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

# Executando, testando e publicando

> Execute um Workflow ou uma única etapa, depure execuções, monte Casos de Teste, publique versões, publique um App, chame a API e agende execuções

Esta página acompanha o exemplo desta seção do primeiro **Executar** em Criar até uma versão publicada usada por um App, pela API e por uma agenda.

## Executando em Criar

**1. Preencha as Entradas**

No painel à direita, digite as Entradas de texto e solte arquivos nas Entradas de arquivo. Entradas obrigatórias precisam estar preenchidas antes de a execução começar.

**2. Clique em Executar**

O botão diz **Executar** na primeira vez e **Reexecutar** depois. Enquanto a execução está em andamento, o cartão de cada etapa mostra o estado dela (**Aguardando Execução**, **Executando**, **Concluído**, **Falhou**, **Pulado**) e o painel mostra o progresso.

**3. Pare se precisar**

**Parar** cancela uma execução ativa; o botão mostra **Cancelando...** até a execução ser marcada como **Cancelado**. Uma etapa que já estava rodando pode terminar antes de o cancelamento ter efeito.

**4. Leia o resultado**

Quando a execução chega a um estado terminal, as abas **Preview** e **Debug** aparecem no painel. Veja [Saídas e resultados](https://docs.tela.com/pt/workflow/outputs-and-results.md#no-painel-de-resultado).

![Criar com o contrato anexado e uma execução em andamento, com o estado de cada etapa](https://mintcdn.com/meistrari/M2w7BduKZAFA1Sbx/images/pt/workflow/run-in-progress.png?fit=max\&auto=format\&n=M2w7BduKZAFA1Sbx\&q=85\&s=2fd7e4765f98e7e4e43af5f63cd5838e)

**Executar** fica desabilitado enquanto o grafo está incompleto (uma etapa com configuração pendente, mostrada como **Configuração pendente** no cartão), enquanto a última alteração ainda está sendo salva, ou enquanto a execução anterior está carregando. Passe o mouse sobre o botão para ver o motivo.

Uma execução nova fixa a versão atual no momento em que começa. Execuções iniciadas em Criar aparecem em Depurar com a origem **Craft**.

### Executando apenas uma etapa

Selecione uma etapa e o botão vira **Executar Etapa N**. Ele executa o Workflow **do início até aquela etapa** com as Entradas atuais e para ali. Use para iterar em um prompt sem pagar pelas etapas seguintes, ou para conferir o que uma Condição decide antes de montar os caminhos dela. As etapas depois da selecionada aparecem como Pulado nessa execução.

### Várias execuções ao mesmo tempo

Quando mais de uma execução do Workflow está ativa (a sua, um Caso de Teste, tarefas da Workstation, chamadas de API), o painel as lista em **Execuções em andamento** com **Status**, **Execução**, **Origem**, **Etapa** atual e **Entradas/Arquivos**. Clique em uma linha para acompanhar aquela execução. A URL carrega a execução selecionada (`executionId`), então dá para compartilhar um link para uma execução específica.

## Depurando uma execução

Para qualquer coisa além de uma olhada rápida, abra a experiência **Depurar**. Ela lista todas as execuções do Workflow e, para cada uma, as entradas, a entrada e a saída de cada etapa, os erros, as decisões das Condições, as iterações dos Mapear, o terminal da Execução de Código, e custo e duração. Os detalhes estão em [Saídas e resultados](https://docs.tela.com/pt/workflow/outputs-and-results.md#em-depurar).

Um ciclo típico quando uma etapa não faz o esperado:

1. Abra a execução que falhou em Depurar e leia a **Entrada** da etapa (o que ela de fato recebeu) e o **Erro**.
2. Se uma referência trouxe um valor vazio, confira o chip `@` em Criar: a etapa pode estar lendo texto quando precisava do arquivo, ou o valor está em outro atributo.
3. Corrija a etapa e use **Executar Etapa N** nela para validar, depois **Reexecutar** o Workflow inteiro.
4. Para testar a correção com as mesmas entradas, abra a execução antiga em Depurar e escolha **Ações da execução** › **Editar no Craft**: o Craft abre na versão mais recente, com as entradas dessa execução já preenchidas, pronto para **Executar**. **Executar novamente**, no mesmo menu, repete as entradas na **mesma versão** da execução original, então use-o para reproduzir um problema, não para conferir uma correção.

> [!TIP]
>
> Dê nomes curtos e significativos às etapas antes de depurar qualquer coisa. É pelo nome que as etapas aparecem em Depurar, na API e no código.

## Casos de Teste

A experiência **Testar** funciona como em um [Canvas](https://docs.tela.com/pt/creating-your-first-canvas.md#executando-e-testando-o-seu-canvas): um **Caso de Teste** é um conjunto de Entradas salvo que você executa de novo depois de cada mudança.

**1. Crie Casos de Teste**

Solte arquivos na experiência Testar para criar um Caso de Teste por arquivo, ou **Criar manualmente** e preencha cada Entrada. Uma tarefa revisada na Workstation também pode virar um Caso de Teste.

**2. Execute**

**Executar Todos**, ou selecione alguns e **Rodar Selecionados**. Cada execução roda o Workflow completo para aquele caso e aparece em Depurar com a origem **Caso de teste**.

**3. Revise os atributos**

Abra um caso e marque cada atributo como **Bom** ou **Ruim**. Adicione **Respostas Esperadas** e **Respostas Erradas** para que as execuções futuras sejam classificadas automaticamente, e **Regras de Validação IA** em linguagem natural ("O total precisa ser um número sem símbolo de moeda") que um juiz de IA aplica em toda execução. Categorias ajudam a agrupar os casos.

**4. Compare versões**

A **Pontuação** e a **Precisão** de uma versão vêm só dos atributos revisados. Troque de versão no **Histórico de Versões** e execute os mesmos casos em cada uma para compará-las antes de publicar. Veja [Comparando versões](https://docs.tela.com/pt/test-cases/comparing-versions.md).

![Experiência Testar com os Casos de Teste do Workflow de contratos](https://mintcdn.com/meistrari/M2w7BduKZAFA1Sbx/images/pt/workflow/test-experience.png?fit=max\&auto=format\&n=M2w7BduKZAFA1Sbx\&q=85\&s=c75886cf287c6aec89e4569b7c0ce81a)

> [!WARNING]
>
> Um Caso de Teste cuja execução terminou fica **Revisão Pendente** (ou **Parcialmente Revisado**), não aprovado. Ele só vira **Concluído** quando todo atributo tem um veredito, seu ou de uma validação. Uma suíte que rodou mas nunca foi revisada não prova nada, então revise antes de publicar. Os status são os mesmos de um Canvas, veja [Executando e revisando Casos de Teste](https://docs.tela.com/pt/test-cases/running-and-reviewing.md#status).

> [!NOTE]
>
> **Testar** fica oculta quando o armazenamento de arquivos está desabilitado no seu Workspace. Executar um Caso de Teste exige que a versão atual do Workflow esteja salva; uma edição que ainda está sendo gravada bloqueia a execução por um instante.

## Publicando

Publicar cria uma versão estável que Apps, a API e as agendas usam. Você continua editando o Workflow livremente depois; só o que você publica está em produção.

**1. Complete todas as etapas**

**Publicar** fica indisponível enquanto uma etapa tem configuração pendente (**Complete todas as etapas primeiro**) ou o Workflow não tem nenhuma etapa.

**2. Mova o Rascunho para um projeto, se precisar**

Em um Rascunho, clicar em **Publicar** abre primeiro **Mover para projeto**. Escolha o projeto; isso não pode ser desfeito, e o Workflow passa a ficar visível para o seu time.

**3. Escolha os ambientes**

No diálogo de publicação, selecione o **Target de publicação**: **Production** por padrão, e qualquer outro ambiente do Workflow. **+ Novo environment** cria um na hora, por exemplo `staging`, para testar a versão pela API antes de Production.

**4. Publique um App, se quiser**

A chave **Publicar App** aparece quando o Workflow ainda não tem App. Ative-a para criar um App da Workstation com esta versão.

**5. Confirme**

O botão diz **Publicar em Production** (ou **Publicar em Production e staging**). Publicar em um ambiente substitui a versão que ele servia; Apps e chamadas de API naquele ambiente passam a usar a nova versão imediatamente.

![Diálogo de publicação do Workflow com Production selecionado e a chave Publicar App](https://mintcdn.com/meistrari/M2w7BduKZAFA1Sbx/images/pt/workflow/publish-menu.png?fit=max\&auto=format\&n=M2w7BduKZAFA1Sbx\&q=85\&s=28fda5350ca7251be2efbc2d63fd042d)

O botão de versão ao lado de **Publicar** abre o **Histórico de Versões**: cada versão salva com o resumo, quem a criou e qual ambiente a serve. Você pode **Visualizar** uma versão passada, **Restaurar** uma delas como a versão que você edita ou editar o resumo de uma versão. Veja [Publicação e ambientes](https://docs.tela.com/pt/craft/publishing.md) para o comportamento compartilhado com Canvases.

### Configurações do Workflow que vale conferir antes de publicar

No menu `…` ao lado do título:

* **Execução** → **Execução paralela**: roda etapas independentes ao mesmo tempo; etapas com dependências de dados continuam rodando em ordem. Ative quando o Workflow tem etapas que não dependem umas das outras e velocidade importa.
* **Credenciais** (administradores): quais credenciais o Workflow pode usar, e valores com escopo do Workflow. Veja [Credenciais](https://docs.tela.com/pt/credentials.md).
* **Tags** personalizadas: gravadas em toda execução, úteis para filtrar o Usage. Veja [Tags](https://docs.tela.com/pt/tags.md).

## Publicando um App

Com **Publicar App** ativo, a publicação cria um [App da Workstation](https://docs.tela.com/pt/workstation/creating-apps.md) ligado à versão publicada. Abra as **Configurações** dele para dar um nome, escolher quem pode acessar, exigir aprovação e ocultá-lo do Dashboard. O seu time então envia documentos, cada um virando uma tarefa, revisa os atributos e aprova; veja [Saídas e resultados](https://docs.tela.com/pt/workflow/outputs-and-results.md#em-um-app-da-workstation).

O App executa a versão com a qual foi publicado. Publicar uma nova versão no ambiente do App o atualiza.

## Chamando o Workflow pela API

**1. Abra Conectar via API**

No menu `…`, escolha **Conectar via API** (desabilitado em Rascunhos: mova para um projeto antes). O diálogo mostra o ID do Workflow e um snippet com as Entradas já listadas.

**2. Envie as Entradas como variables**

Chame `POST /v2/chat/completions` com `canvas_id` igual ao ID do Workflow e `variables` com as Entradas pelo nome, texto ou [arquivos](https://docs.tela.com/pt/completion-api/variables-and-files.md). Acrescente `environment_name` para executar a versão publicada em outro ambiente.

**3. Escolha como esperar**

Workflows demoram mais do que um único prompt. Use `async: true` e faça polling, ou `webhook_url` para ser chamado de volta. Veja [Async e webhooks](https://docs.tela.com/pt/completion-api/async-and-webhooks.md).

**4. Leia as etapas se precisar**

Use a API de Workflow Run para listar execuções e ler cada etapa; veja [Saídas e resultados](https://docs.tela.com/pt/workflow/outputs-and-results.md#pela-api).

```sh cURL theme={null}
curl -X POST https://api.tela.com/v2/chat/completions \
    -H 'Content-Type: application/json' \
    -H "Authorization: Bearer $TELA_API_KEY" \
    -d '{
        "canvas_id": "9d2e4f6a-1b3c-4d5e-8f70-1a2b3c4d5e6f",
        "variables": {
            "contract": { "file_url": "https://example.com/contracts/acme.pdf" },
            "requester": "maria@example.com"
        },
        "async": true
    }'
```

```typescript TypeScript Tela SDK theme={null}
import { createTelaClient } from '@meistrari/tela-sdk-js'

const tela = createTelaClient({ apiKey: process.env.TELA_API_KEY })

const run = await tela.completions.create({
    canvasId: process.env.TELA_WORKFLOW_ID,
    variables: {
        contract: tela.createFile('https://example.com/contracts/acme.pdf'),
        requester: 'maria@example.com',
    },
    webhookUrl: 'https://example.com/webhooks/tela',
})
```

```python Python Tela SDK theme={null}
import os
from tela import create_tela_client

client = create_tela_client(api_key=os.getenv("TELA_API_KEY"))

run = client.completions.create(
    canvas_id=os.getenv("TELA_WORKFLOW_ID"),
    variables={
        "contract": client.create_file("https://example.com/contracts/acme.pdf"),
        "requester": "maria@example.com",
    },
    webhook_url="https://example.com/webhooks/tela",
)
```

Para criar **tarefas** no App em vez de completions, passe `application_id` em vez de `canvas_id`; veja [Criando tarefas via API](https://docs.tela.com/pt/creating-tasks.md).

## Executando em uma agenda

Um Workflow com uma versão em **Production** pode rodar sozinho a partir de **Agendas**: abra o menu `…` ao lado do título e escolha **Agendar**, ou vá em **Agendas** e clique em **Nova agenda**. Cada disparo é uma execução comum: aparece em Depurar com a origem **Agenda**, e em Usage. O passo a passo completo está em [Agendas](https://docs.tela.com/pt/schedules/overview.md).

* A agenda executa a versão que estiver em Production na hora da execução, então publicar uma nova versão em Production muda o que o próximo disparo roda.
* **Pausar** interrompe novos disparos; **Retomar** continua a partir do próximo horário previsto, sem repetir os perdidos.
* Uma agenda recorrente que continua falhando é pausada automaticamente e quem a criou é avisado.

> [!NOTE]
>
> Uma agenda decide quando uma execução **começa**; não existe etapa de espera ou atraso dentro de um Workflow. Uma execução que fica 3 horas sem progresso é marcada como **Tempo esgotado**. Para um processo que espera horas ou dias por algo externo, faça dois Workflows (ou duas agendas): um que registra o que está pendente e outro que retoma.

![Página de Agendas com uma agenda recorrente para o Workflow de contratos](https://mintcdn.com/meistrari/M2w7BduKZAFA1Sbx/images/pt/workflow/schedules.png?fit=max\&auto=format\&n=M2w7BduKZAFA1Sbx\&q=85\&s=38805de789407a02be001bb0f1fa4e76)

## Checklist antes de ir para produção

* Todas as etapas com nome, nenhuma **Configuração pendente**.
* Todo valor revisável é um atributo de um Formato de Saída.
* Os caminhos terminam do jeito que quem consome espera (mesmos atributos, ou um Conectar em uma etapa final).
* Casos de Teste revisados na versão que você está prestes a publicar.
* Credenciais criadas no Workspace e permitidas para este Workflow.
* Publicado em `staging` e chamado pela API uma vez, depois publicado em **Production**.


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