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

# Context

> Referência completa do objeto ctx disponível em cada handler: empresa, canal, usuário, trigger, ambiente, mensagens, memória e mais.

O objeto `ctx` é o segundo parâmetro de todo handler. Contém informações da empresa, canal, usuário, tipo de trigger, e dá acesso a secrets, mensagens, memória e logging.

```typescript theme={null}
handler: async (input, ctx, request) => {
  ctx.log("Requisição recebida", {
    company: ctx.company.name,
    bot: ctx.bot.channel,
    user: ctx.user.id,
  });
}
```

## Referência

| Propriedade | Tipo | Descrição |
| - | - | - |
| `ctx.functionSlug` | `string` | Slug da função |
| `ctx.company` | `{ id, name }` | Empresa da requisição |
| `ctx.bot` | `{ id, name, channel }` | Canal que originou a requisição |
| `ctx.user` | `{ id, names?, roomId? }` | Usuário da conversa |
| `ctx.trigger` | `TriggerInfo` | Tipo de trigger (http, cron, event) |
| `ctx.env` | `EnvAccessor` | Acesso a secrets |
| `ctx.params` | `Record<string, string>` | Parâmetros de rota |
| `ctx.query` | `Record<string, string>` | Query string params |
| `ctx.jelou` | `JelouSDK` | Mensageria WhatsApp e execuções diferidas |
| `ctx.memory` | `MemorySDK` | Memória de sessão key-value |
| `ctx.templateRegistry` | `TemplateRegistry` | Catálogo de templates WhatsApp aprovados |
| `ctx.guard` | `Guard` | Cadeia de verificações antes de agir |
| `ctx.verifyStripe()` etc. | `(req) => Promise<void>` | Verificação de assinatura de webhooks |
| `ctx.method` | `string` | Método HTTP |
| `ctx.path` | `string` | Path da requisição |
| `ctx.requestId` | `string` | UUID único |
| `ctx.isCron` | `boolean` | `true` se trigger cron |
| `ctx.isEvent` | `boolean` | `true` se trigger event |
| `ctx.isHttp` | `boolean` | `true` se requisição HTTP |
| `ctx.isScheduledFire` | `boolean` | `true` se é o disparo de uma execução diferida |
| `ctx.skillId` | `string \| null` | ID do fluxo do Brain Studio |
| `ctx.executionId` | `string \| null` | ID de execução do Brain Studio |
| `ctx.log()` | `(...args) => void` | Logger estruturado |

## Identidade

```typescript theme={null}
ctx.company.id;    // 42
ctx.company.name;  // "Loja ABC"
ctx.bot.id;        // "bot-123"
ctx.bot.channel;   // "whatsapp"
ctx.user.id;       // 99
```

## Trigger

> [tab] HTTP
>
> ```typescript theme={null}
> if (ctx.isHttp) {
>   ctx.trigger; // { type: "http" }
> }
> ```

> [tab] Cron
>
> ```typescript theme={null}
> if (ctx.isCron) {
>   ctx.trigger.cron; // "0 9 * * *"
> }
> ```

> [tab] Event
>
> ```typescript theme={null}
> if (ctx.isEvent) {
>   ctx.trigger.event; // "payment.completed"
> }
> ```

## Request

```typescript theme={null}
export default define({
  config: { path: "/users/:id" },
  handler: async (input, ctx) => {
    ctx.params.id;   // "42"
    ctx.query.format // "json"
    ctx.requestId;   // "a1b2c3d4-..."
  },
});
```

## Ambiente (secrets)

```typescript theme={null}
const apiKey = ctx.env.get("CRM_API_KEY");
ctx.env.has("WEBHOOK_SECRET");
```

> [!NOTE]
>
> Variáveis internas com prefixo `__FN_` são bloqueadas.

## Execuções diferidas (`ctx.jelou.schedule`)

Agende uma execução futura da sua própria função:

```typescript theme={null}
await ctx.jelou.schedule({
  in: "24h",
  path: "/enviar-followup",
  payload: { userId: input.userId, botId: ctx.bot.id },
  subject: `user_${input.userId}`,
});
```

> [card] [Guia de execuções diferidas](https://docs.jelou.ai/pt/guias/funcoes/diferidas.md)
>
> Agendar, consultar, cancelar e verificar antes de agir.

## Verificações (`ctx.guard`)

Encadeie condições e execute a ação apenas se todas se cumprirem. Útil quando a realidade pode ter mudado desde o agendamento:

```typescript theme={null}
return ctx.guard
  .when("semPagar", async () => !(await consultarPedido(input.pedidoId)).pago)
  .run(async () => {
    await ctx.jelou.send({ type: "text", to: input.telefone, text: "Seu pagamento está pendente" });
    return { enviado: true };
  });
```

Se alguma verificação retornar um valor falso, a cadeia é interrompida e retorna `{ skipped: "<nome>" }` sem executar a ação.

## Webhooks (`ctx.verify*`)

Verifique a assinatura de um webhook antes de processá-lo:

```typescript theme={null}
async handler(event, ctx, request) {
  await ctx.verifyStripe(request);
  return { received: true };
}
```

> [card] [Guia de webhooks](https://docs.jelou.ai/pt/guias/funcoes/webhooks.md)
>
> Stripe, Shopify, Meta e assinaturas HMAC genéricas.

## Logging

```typescript theme={null}
ctx.log("Processando pedido", { telefone: input.telefone });
// stdout: { "requestId": "...", "function": "...", "timestamp": "...", "args": [...] }
```

> [card] [Mensagens](https://docs.jelou.ai/pt/guias/funcoes/mensajeria.md)
>
> Enviar WhatsApp com ctx.jelou.

> [card] [Memória](https://docs.jelou.ai/pt/guias/funcoes/memoria.md)
>
> Persistir dados com ctx.memory.


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