# Ganchos de ciclo de vida de sessão

Os ganchos de ciclo de vida da sessão permitem que você responda aos eventos de início e término da sessão. Use-os para:

<!-- markdownlint-disable GHD046 GHD005 -->

<!-- Suppressed: GHD046 (outdated release terminology), GHD005 (hardcoded data variable) -->

* Inicialize o contexto quando as sessões começarem
* Limpar recursos quando as sessões terminarem
* Acompanhar as métricas e análises da sessão
* Configurar o comportamento da sessão dinamicamente

## Gancho de início da sessão {#session-start}

O `onSessionStart` gancho é chamado quando uma sessão é iniciada (nova ou retomada).

### Assinatura de Hook

<div class="ghd-codetabs">
<div class="ghd-codetab" data-lang="typescript" data-label="TypeScript"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">TypeScript</div>

```typescript
type SessionStartHandler = (
  input: SessionStartHookInput,
  invocation: HookInvocation
) => Promise<SessionStartHookOutput | null | undefined>;
```

</div>

<div class="ghd-codetab" data-lang="python" data-label="Python"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Python</div>

```python
SessionStartHandler = Callable[
    [SessionStartHookInput, dict[str, str]],
    Awaitable[SessionStartHookOutput | None]
]
```

</div>

<div class="ghd-codetab" data-lang="go" data-label="Go"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Go</div>

```golang
type SessionStartHandler func(
    input SessionStartHookInput,
    invocation HookInvocation,
) (*SessionStartHookOutput, error)
```

</div>

<div class="ghd-codetab" data-lang="dotnet" data-label=".NET"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">.NET</div>

```csharp
public delegate Task<SessionStartHookOutput?> SessionStartHandler(
    SessionStartHookInput input,
    HookInvocation invocation);
```

</div>

<div class="ghd-codetab" data-lang="java" data-label="Java"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Java</div>

```java
@FunctionalInterface
public interface SessionStartHandler {
    CompletableFuture<SessionStartHookOutput> handle(
        SessionStartHookInput input,
        HookInvocation invocation);
}
```

</div>

</div>

### Entrada

| Campo                      | Tipo                               | Descrição                                                     |
| -------------------------- | ---------------------------------- | ------------------------------------------------------------- |
| `timestamp`                | number                             | Carimbo de data/hora Unix de quando o gancho foi desencadeado |
| `cwd`                      | cadeia                             | Diretório de trabalho atual                                   |
| `source`                   |                                    |                                                               |
| `"startup"`                |                                    |                                                               |
| \|                         |                                    |                                                               |
| `"resume"`                 |                                    |                                                               |
| \|                         |                                    |                                                               |
| `"new"`                    |                                    |                                                               |
| Como a sessão foi iniciada |                                    |                                                               |
| `initialPrompt`            | cadeia de caracteres \| indefinida | O prompt inicial, se fornecido                                |

### Saída

| Campo               | Tipo   | Descrição                                     |
| ------------------- | ------ | --------------------------------------------- |
| `additionalContext` | cadeia | Contexto a ser adicionado no início da sessão |
| `modifiedConfig`    | objeto | Sobrepor configuração de sessão               |

### Exemplos

#### Adicionar contexto de projeto no início

<div class="ghd-codetabs">
<div class="ghd-codetab" data-lang="typescript" data-label="TypeScript"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">TypeScript</div>

```typescript
const session = await client.createSession({
  hooks: {
    onSessionStart: async (input, invocation) => {
      console.log(`Session ${invocation.sessionId} started (${input.source})`);
      
      const projectInfo = await detectProjectType(input.cwd);
      
      return {
        additionalContext: `
This is a ${projectInfo.type} project.
Main language: ${projectInfo.language}
Package manager: ${projectInfo.packageManager}
        `.trim(),
      };
    },
  },
});
```

</div>

<div class="ghd-codetab" data-lang="python" data-label="Python"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Python</div>

```python
from copilot.session import PermissionHandler

async def on_session_start(input_data, invocation):
    print(f"Session {invocation['session_id']} started ({input_data['source']})")
    
    project_info = await detect_project_type(input_data["cwd"])
    
    return {
        "additionalContext": f"""
This is a {project_info['type']} project.
Main language: {project_info['language']}
Package manager: {project_info['packageManager']}
        """.strip()
    }

session = await client.create_session(on_permission_request=PermissionHandler.approve_all, hooks={"on_session_start": on_session_start})
```

</div>

</div>

#### Lidar com a retomada de sessão

```typescript
const session = await client.createSession({
  hooks: {
    onSessionStart: async (input, invocation) => {
      if (input.source === "resume") {
        // Load previous session state
        const previousState = await loadSessionState(invocation.sessionId);
        
        return {
          additionalContext: `
Session resumed. Previous context:
- Last topic: ${previousState.lastTopic}
- Open files: ${previousState.openFiles.join(", ")}
          `.trim(),
        };
      }
      return null;
    },
  },
});
```

#### Carregar preferências do usuário

```typescript
const session = await client.createSession({
  hooks: {
    onSessionStart: async () => {
      const preferences = await loadUserPreferences();
      
      const contextParts = [];
      
      if (preferences.language) {
        contextParts.push(`Preferred language: ${preferences.language}`);
      }
      if (preferences.codeStyle) {
        contextParts.push(`Code style: ${preferences.codeStyle}`);
      }
      if (preferences.verbosity === "concise") {
        contextParts.push("Keep responses brief and to the point.");
      }
      
      return {
        additionalContext: contextParts.join("\n"),
      };
    },
  },
});
```

## Gancho de fim de sessão {#session-end}

O `onSessionEnd` gancho é invocado quando uma sessão termina.

### Assinatura de Hook

<div class="ghd-codetabs">
<div class="ghd-codetab" data-lang="typescript" data-label="TypeScript"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">TypeScript</div>

```typescript
type SessionEndHandler = (
  input: SessionEndHookInput,
  invocation: HookInvocation
) => Promise<SessionEndHookOutput | null | undefined>;
```

</div>

<div class="ghd-codetab" data-lang="python" data-label="Python"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Python</div>

```python
SessionEndHandler = Callable[
    [SessionEndHookInput, dict[str, str]],
    Awaitable[SessionEndHookOutput | None]
]
```

</div>

<div class="ghd-codetab" data-lang="go" data-label="Go"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Go</div>

```golang
type SessionEndHandler func(
    input SessionEndHookInput,
    invocation HookInvocation,
) (*SessionEndHookOutput, error)
```

</div>

<div class="ghd-codetab" data-lang="dotnet" data-label=".NET"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">.NET</div>

```csharp
public delegate Task<SessionEndHookOutput?> SessionEndHandler(
    SessionEndHookInput input,
    HookInvocation invocation);
```

</div>

<div class="ghd-codetab" data-lang="java" data-label="Java"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Java</div>

```java
@FunctionalInterface
public interface SessionEndHandler {
    CompletableFuture<SessionEndHookOutput> handle(
        SessionEndHookInput input,
        HookInvocation invocation);
}
```

</div>

</div>

### Entrada

| Campo          | Tipo                               | Descrição                                                     |
| -------------- | ---------------------------------- | ------------------------------------------------------------- |
| `timestamp`    | number                             | Carimbo de data/hora Unix de quando o gancho foi desencadeado |
| `cwd`          | cadeia                             | Diretório de trabalho atual                                   |
| `reason`       | cadeia                             | Por que a sessão terminou (veja abaixo)                       |
| `finalMessage` | cadeia de caracteres \| indefinida | A última mensagem da sessão                                   |
| `error`        | cadeia de caracteres \| indefinida | Mensagem de erro se a sessão terminou devido a um erro        |

#### Motivos finais

| Reason        | Descrição                                          |
| ------------- | -------------------------------------------------- |
| `"complete"`  | Sessão concluída normalmente                       |
| `"error"`     | Sessão encerrada devido a um erro                  |
| `"abort"`     | A sessão foi abortada pelo usuário ou pelo código. |
| `"timeout"`   | Sessão expirada                                    |
| `"user_exit"` | O usuário encerrou explicitamente a sessão         |

### Saída

| Campo            | Tipo      | Descrição                                       |
| ---------------- | --------- | ----------------------------------------------- |
| `suppressOutput` | boolean   | Suprimir a saída final da sessão                |
| `cleanupActions` | string\[] | Lista de ações de limpeza a serem executadas    |
| `sessionSummary` | cadeia    | Resumo da sessão para registro/análise de dados |

### Exemplos

#### Acompanhar métricas de sessão

<div class="ghd-codetabs">
<div class="ghd-codetab" data-lang="typescript" data-label="TypeScript"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">TypeScript</div>

```typescript
const sessionStartTimes = new Map<string, number>();

const session = await client.createSession({
  hooks: {
    onSessionStart: async (input, invocation) => {
      sessionStartTimes.set(invocation.sessionId, input.timestamp);
      return null;
    },
    onSessionEnd: async (input, invocation) => {
      const startTime = sessionStartTimes.get(invocation.sessionId);
      const duration = startTime ? input.timestamp - startTime : 0;
      
      await recordMetrics({
        sessionId: invocation.sessionId,
        duration,
        endReason: input.reason,
      });
      
      sessionStartTimes.delete(invocation.sessionId);
      return null;
    },
  },
});
```

</div>

<div class="ghd-codetab" data-lang="python" data-label="Python"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Python</div>

```python
from copilot.session import PermissionHandler

session_start_times = {}

async def on_session_start(input_data, invocation):
    session_start_times[invocation["session_id"]] = input_data["timestamp"]
    return None

async def on_session_end(input_data, invocation):
    start_time = session_start_times.get(invocation["session_id"])
    duration = input_data["timestamp"] - start_time if start_time else 0
    
    await record_metrics({
        "session_id": invocation["session_id"],
        "duration": duration,
        "end_reason": input_data["reason"],
    })
    
    session_start_times.pop(invocation["session_id"], None)
    return None

session = await client.create_session(on_permission_request=PermissionHandler.approve_all, hooks={
        "on_session_start": on_session_start,
        "on_session_end": on_session_end,
    })
```

</div>

</div>

#### Limpar os recursos

```typescript
const sessionResources = new Map<string, { tempFiles: string[] }>();

const session = await client.createSession({
  hooks: {
    onSessionStart: async (input, invocation) => {
      sessionResources.set(invocation.sessionId, { tempFiles: [] });
      return null;
    },
    onSessionEnd: async (input, invocation) => {
      const resources = sessionResources.get(invocation.sessionId);
      
      if (resources) {
        // Clean up temp files
        for (const file of resources.tempFiles) {
          await fs.unlink(file).catch(() => {});
        }
        sessionResources.delete(invocation.sessionId);
      }
      
      console.log(`Session ${invocation.sessionId} ended: ${input.reason}`);
      return null;
    },
  },
});
```

#### Salvar o estado da sessão para retomar

```typescript
const session = await client.createSession({
  hooks: {
    onSessionEnd: async (input, invocation) => {
      if (input.reason !== "error") {
        // Save state for potential resume
        await saveSessionState(invocation.sessionId, {
          endTime: input.timestamp,
          cwd: input.cwd,
          reason: input.reason,
        });
      }
      return null;
    },
  },
});
```

#### Resumo da sessão de log

```typescript
const sessionData: Record<string, { prompts: number; tools: number; startTime: number }> = {};

const session = await client.createSession({
  hooks: {
    onSessionStart: async (input, invocation) => {
      sessionData[invocation.sessionId] = { 
        prompts: 0, 
        tools: 0, 
        startTime: input.timestamp 
      };
      return null;
    },
    onUserPromptSubmitted: async (_, invocation) => {
      sessionData[invocation.sessionId].prompts++;
      return null;
    },
    onPreToolUse: async (_, invocation) => {
      sessionData[invocation.sessionId].tools++;
      return { permissionDecision: "allow" };
    },
    onSessionEnd: async (input, invocation) => {
      const data = sessionData[invocation.sessionId];
      console.log(`
Session Summary:
  ID: ${invocation.sessionId}
  Duration: ${(input.timestamp - data.startTime) / 1000}s
  Prompts: ${data.prompts}
  Tool calls: ${data.tools}
  End reason: ${input.reason}
      `.trim());
      
      delete sessionData[invocation.sessionId];
      return null;
    },
  },
});
```

## Gancho de parada do agente {#agent-stop}

O gancho de parada do agente é executado quando o agente de nível superior naturalmente atinge o final de uma curva. Ela é separada de `onSessionEnd`: a sessão permanece ativa e o gancho pode solicitar a volta de outro agente.

| Linguagem          | Manipulador      |
| ------------------ | ---------------- |
| Node.js/TypeScript | `onAgentStop`    |
| Python             | `on_agent_stop`  |
| Go                 | `OnAgentStop`    |
| .NET               | `OnAgentStop`    |
| Rust               | `on_agent_stop`  |
| Java               | `setOnAgentStop` |

### Entrada

Os nomes de membros públicos seguem as convenções de maiúsculas e minúsculas de cada idioma:

| Meaning                                                     | Node.js/Python   | Go / .NET        | Rust               | Java                  |
| ----------------------------------------------------------- | ---------------- | ---------------- | ------------------ | --------------------- |
| Por que o agente parou, por exemplo `end_turn`              | `stopReason`     | `StopReason`     | `stop_reason`      | `getStopReason()`     |
| Caminho para a transcrição da sessão no disco               | `transcriptPath` | `TranscriptPath` | `transcript_path`  | `getTranscriptPath()` |
| Se uma decisão de bloco anterior já forçou essa continuação | `stopHookActive` | `StopHookActive` | `stop_hook_active` | `getStopHookActive()` |

### Saída

Não produza saída para que o agente pare. Retorne uma decisão de bloqueio para enfileirar outra mensagem do usuário e continuar:

```json
{
  "decision": "block",
  "reason": "Run the final validation and fix any failures."
}
```

Use o membro de parada ativa listado acima para evitar bloquear repetidamente um agente que já tenha continuado devido a esse gancho. O ambiente de execução também impõe um limite ao número de decisões de bloqueio consecutivas.

## Práticas recomendadas

1. **Mantenha `onSessionStart` rápido** – os usuários estão aguardando a sessão ficar pronta.

2. **Trate todos os motivos de encerramento** – não presuma que as sessões se encerrem sem problemas; trate erros e abortos.

3. **Limpar recursos** – Use `onSessionEnd` para liberar todos os recursos alocados durante a sessão.

4. **Armazenar o estado mínimo** – se estiver acompanhando os dados da sessão, mantenha-os leves.

5. **Tornar a limpeza idempotente** - `onSessionEnd` pode não ser chamado se o processo falhar.

## Consulte também

* [Usar ganchos](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/hooks)
* [Gancho de tratamento de erros](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/hooks/error-handling)
* [Guia de depuração](/pt/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/troubleshooting/debugging)