TypeScript
```typescript
type ErrorOccurredHandler = (
input: ErrorOccurredHookInput,
invocation: HookInvocation
) => Promise
;
```
Python
```python
ErrorOccurredHandler = Callable[
[ErrorOccurredHookInput, dict[str, str]],
Awaitable[ErrorOccurredHookOutput | None]
]
```
Go
```golang
type ErrorOccurredHandler func(
input ErrorOccurredHookInput,
invocation HookInvocation,
) (*ErrorOccurredHookOutput, error)
```
.NET
```csharp
public delegate Task
ErrorOccurredHandler(
ErrorOccurredHookInput input,
HookInvocation invocation);
```
Java
```java
// Note: Java SDK does not have an onErrorOccurred hook.
// Use EventErrorPolicy and EventErrorHandler instead:
//
// session.setEventErrorPolicy(EventErrorPolicy.SUPPRESS_AND_LOG_ERRORS);
// session.setEventErrorHandler((event, ex) -> {
// System.err.println("Error in " + event.getType() + ": " + ex.getMessage());
// });
//
// See the "Basic Error Logging" example below for a complete snippet.
```
## 입력
| Field | Type | Description |
| -------------- | ------- | --------------------------------------------------------------------------- |
| `timestamp` | number | 오류가 발생한 시점의 Unix 타임스탬프 |
| `cwd` | string | 현재 작업 디렉터리 |
| `error` | string | 오류 메시지 |
| `errorContext` | string | 오류가 발생한 위치: `"model_call"`, `"tool_execution"`, `"system"`또는 `"user_input"` |
| `recoverable` | boolean | 오류를 복구할 수 있는지 여부 |
## 출력
기본 오류 처리를 위해 `null`를 반환하거나 `undefined`를 사용합니다. 그렇지 않으면 다음과 같은 객체를 반환합니다:
| Field | Type | Description |
| ------------------ | ------- | -------------------------------------- |
| `suppressOutput` | boolean | true이면 사용자에게 오류 출력을 표시하지 마세요. |
| `errorHandling` | string | 처리 방법: `"retry"`, `"skip"`또는 `"abort"` |
| `retryCount` | number | 다시 시도할 횟수(errorHandling인 `"retry"`경우) |
| `userNotification` | string | 사용자를 표시하는 사용자 지정 메시지 |
## 예제
### 기본 오류 로깅
TypeScript
```typescript
const session = await client.createSession({
hooks: {
onErrorOccurred: async (input, invocation) => {
console.error(`[${invocation.sessionId}] Error: ${input.error}`);
console.error(` Context: ${input.errorContext}`);
console.error(` Recoverable: ${input.recoverable}`);
return null;
},
},
});
```
Python
```python
from copilot.session import PermissionHandler
async def on_error_occurred(input_data, invocation):
print(f"[{invocation['session_id']}] Error: {input_data['error']}")
print(f" Context: {input_data['errorContext']}")
print(f" Recoverable: {input_data['recoverable']}")
return None
session = await client.create_session(on_permission_request=PermissionHandler.approve_all, hooks={"on_error_occurred": on_error_occurred})
```
Go
```golang
session, _ := client.CreateSession(context.Background(), &copilot.SessionConfig{
Hooks: &copilot.SessionHooks{
OnErrorOccurred: func(input copilot.ErrorOccurredHookInput, inv copilot.HookInvocation) (*copilot.ErrorOccurredHookOutput, error) {
fmt.Printf("[%s] Error: %s\n", inv.SessionID, input.Error)
fmt.Printf(" Context: %s\n", input.ErrorContext)
fmt.Printf(" Recoverable: %v\n", input.Recoverable)
return nil, nil
},
},
})
```
.NET
```csharp
var session = await client.CreateSessionAsync(new SessionConfig
{
Hooks = new SessionHooks
{
OnErrorOccurred = (input, invocation) =>
{
Console.Error.WriteLine($"[{invocation.SessionId}] Error: {input.Error}");
Console.Error.WriteLine($" Context: {input.ErrorContext}");
Console.Error.WriteLine($" Recoverable: {input.Recoverable}");
return Task.FromResult
(null);
},
},
});
```
Java
```java
import com.github.copilot.*;
import com.github.copilot.rpc.*;
// Note: Java SDK does not have an onErrorOccurred hook.
// Use EventErrorPolicy and EventErrorHandler instead:
var session = client.createSession(
new SessionConfig()
.setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();
session.setEventErrorPolicy(EventErrorPolicy.SUPPRESS_AND_LOG_ERRORS);
session.setEventErrorHandler((event, ex) -> {
System.err.println("[" + session.getSessionId() + "] Error: " + ex.getMessage());
System.err.println(" Event: " + event.getType());
});
```
### 모니터링 서비스에 오류 보내기
```typescript
import { captureException } from "@sentry/node"; // or your monitoring service
const session = await client.createSession({
hooks: {
onErrorOccurred: async (input, invocation) => {
captureException(new Error(input.error), {
tags: {
sessionId: invocation.sessionId,
errorContext: input.errorContext,
},
extra: {
error: input.error,
recoverable: input.recoverable,
cwd: input.cwd,
},
});
return null;
},
},
});
```
### 사용자에게 친숙한 오류 메시지
```typescript
const ERROR_MESSAGES: Record