Error Handling Hook

import type { ErrorOccurredHookInput, HookInvocation, ErrorOccurredHookOutput } from "@github/copilot-sdk";
type ErrorOccurredHandler = (
  input: ErrorOccurredHookInput,
  invocation: HookInvocation
) => Promise<ErrorOccurredHookOutput | null | undefined>;

type ErrorOccurredHandler = (
  input: ErrorOccurredHookInput,
  invocation: HookInvocation
) => Promise<ErrorOccurredHookOutput | null | undefined>;

from copilot.session import ErrorOccurredHookInput, ErrorOccurredHookOutput
from typing import Callable, Awaitable

ErrorOccurredHandler = Callable[
    [ErrorOccurredHookInput, dict[str, str]],
    Awaitable[ErrorOccurredHookOutput | None]
]

ErrorOccurredHandler = Callable[
    [ErrorOccurredHookInput, dict[str, str]],
    Awaitable[ErrorOccurredHookOutput | None]
]

package main

import copilot "github.com/github/copilot-sdk/go"

type ErrorOccurredHandler func(
    input copilot.ErrorOccurredHookInput,
    invocation copilot.HookInvocation,
) (*copilot.ErrorOccurredHookOutput, error)

func main() {}

type ErrorOccurredHandler func(
    input ErrorOccurredHookInput,
    invocation HookInvocation,
) (*ErrorOccurredHookOutput, error)

using GitHub.Copilot.SDK;

public delegate Task<ErrorOccurredHookOutput?> ErrorOccurredHandler(
    ErrorOccurredHookInput input,
    HookInvocation invocation);

public delegate Task<ErrorOccurredHookOutput?> ErrorOccurredHandler(
    ErrorOccurredHookInput input,
    HookInvocation invocation);

// 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.

type ErrorOccurredHandler = Box<dyn Fn(
    ErrorOccurredHookInput,
    HookInvocation,
) -> Pin<Box<dyn Future<Output = Option<ErrorOccurredHookOutput>>>> + Send + Sync>;

# on_error_occurred receives input hash and invocation hash,
# returns an ErrorOccurredHookOutput hash or nil.
on_error_occurred = ->(input, invocation) { nil }

// ErrorOccurredHandler receives $input and $invocation arrays,
// returns an ErrorOccurredHookOutput array or null.
$onErrorOccurred = function (array $input, array $invocation): ?array {
    return null;
};

typealias ErrorOccurredHandler = (
    ErrorOccurredHookInput,
    HookInvocation
) async throws -> ErrorOccurredHookOutput?

typealias ErrorOccurredHandler = suspend (
    input: ErrorOccurredHookInput,
    invocation: HookInvocation
) -> ErrorOccurredHookOutput?

using ErrorOccurredHandler = std::function<
    std::optional<ErrorOccurredHookOutput>(
        const ErrorOccurredHookInput& input,
        const HookInvocation& invocation
    )>;

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;
    },
  },
});

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})

package main

import (
	"context"
	"fmt"
	copilot "github.com/github/copilot-sdk/go"
)

func main() {
	client := copilot.NewClient(nil)
	session, _ := client.CreateSession(context.Background(), &copilot.SessionConfig{
		OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
		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
			},
		},
	})
	_ = session
}

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
        },
    },
})

using GitHub.Copilot.SDK;

public static class ErrorHandlingExample
{
    public static async Task Main()
    {
        await using var client = new CopilotClient();
        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<ErrorOccurredHookOutput?>(null);
                },
            },
        });
    }
}

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<ErrorOccurredHookOutput?>(null);
        },
    },
});

import com.github.copilot.sdk.*;
import com.github.copilot.sdk.json.*;

// 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());
});

let session = client.create_session(&SessionConfig {
    hooks: Some(SessionHooks {
        on_error_occurred: Some(Box::new(|input, invocation| {
            Box::pin(async move {
                eprintln!("[{}] Error: {}", invocation.session_id, input.error);
                eprintln!("  Context: {}", input.error_context);
                eprintln!("  Recoverable: {}", input.recoverable);
                None
            })
        })),
        ..Default::default()
    }),
    ..Default::default()
}).await?;

session = client.create_session(
  on_permission_request: ->(_req, _inv) { { kind: "approved" } },
  hooks: {
    on_error_occurred: ->(input, invocation) {
      warn "[#{invocation[:session_id]}] Error: #{input[:error]}"
      warn "  Context: #{input[:errorContext]}"
      warn "  Recoverable: #{input[:recoverable]}"
      nil
    }
  }
)

$session = $client->createSession([
    'hooks' => [
        'onErrorOccurred' => function (array $input, array $invocation): ?array {
            fwrite(STDERR, "[{$invocation['sessionId']}] Error: {$input['error']}\n");
            fwrite(STDERR, "  Context: {$input['errorContext']}\n");
            fwrite(STDERR, "  Recoverable: {$input['recoverable']}\n");
            return null;
        },
    ],
]);

let session = try await client.createSession(config: SessionConfig(
    hooks: SessionHooks(
        onErrorOccurred: { input, invocation in
            print("[\\(invocation.sessionId)] Error: \\(input.error)", to: &stderr)
            print("  Context: \\(input.errorContext)", to: &stderr)
            print("  Recoverable: \\(input.recoverable)", to: &stderr)
            return nil
        }
    )
))

val session = client.createSession(SessionConfig(
    hooks = SessionHooks(
        onErrorOccurred = { input, invocation ->
            System.err.println("[${invocation.sessionId}] Error: ${input.error}")
            System.err.println("  Context: ${input.errorContext}")
            System.err.println("  Recoverable: ${input.recoverable}")
            null
        }
    )
))

auto session = client.createSession({
    .hooks = {
        .onErrorOccurred = [](const ErrorOccurredHookInput& input,
                              const HookInvocation& invocation)
            -> std::optional<ErrorOccurredHookOutput> {
            std::cerr << "[" << invocation.sessionId << "] Error: " << input.error << "\n";
            std::cerr << "  Context: " << input.errorContext << "\n";
            std::cerr << "  Recoverable: " << input.recoverable << "\n";
            return std::nullopt;
        },
    },
});