TypeScript
```typescript
import type { SessionStartHookInput, HookInvocation, SessionStartHookOutput } from "@github/copilot-sdk";
type SessionStartHandler = (
input: SessionStartHookInput,
invocation: HookInvocation
) => Promise
;
```
```typescript
type SessionStartHandler = (
input: SessionStartHookInput,
invocation: HookInvocation
) => Promise;
```
Python
```python
from copilot.session import SessionStartHookInput, SessionStartHookOutput
from typing import Callable, Awaitable
SessionStartHandler = Callable[
[SessionStartHookInput, dict[str, str]],
Awaitable[SessionStartHookOutput | None]
]
```
```python
SessionStartHandler = Callable[
[SessionStartHookInput, dict[str, str]],
Awaitable[SessionStartHookOutput | None]
]
```
Go
```golang
package main
import copilot "github.com/github/copilot-sdk/go"
type SessionStartHandler func(
input copilot.SessionStartHookInput,
invocation copilot.HookInvocation,
) (*copilot.SessionStartHookOutput, error)
func main() {}
```
```golang
type SessionStartHandler func(
input SessionStartHookInput,
invocation HookInvocation,
) (*SessionStartHookOutput, error)
```
.NET
```csharp
using GitHub.Copilot;
public delegate Task
SessionStartHandler(
SessionStartHookInput input,
HookInvocation invocation);
```
```csharp
public delegate Task SessionStartHandler(
SessionStartHookInput input,
HookInvocation invocation);
```
Java
```java
import com.github.copilot.rpc.*;
import java.util.concurrent.CompletableFuture;
public class SessionStartSignature {
SessionStartHandler handler = (SessionStartHookInput input, HookInvocation invocation) ->
CompletableFuture.completedFuture(null);
public static void main(String[] args) {}
}
```
```java
@FunctionalInterface
public interface SessionStartHandler {
CompletableFuture
handle(
SessionStartHookInput input,
HookInvocation invocation);
}
```
### 输入
| 领域 | 类型 | 说明 |
| --------------- | ---------- | --------------- |
| `timestamp` | number | 触发挂钩时的 Unix 时间戳 |
| `cwd` | 字符串 | 当前工作目录 |
| `source` | | |
| `"startup"` | | |
| \| | | |
| `"resume"` | | |
| \| | | |
| `"new"` | | |
| 会话的启动方式 | | |
| `initialPrompt` | 字符串 \| 未定义 | 提供的初始提示 |
### 输出
| 领域 | 类型 | 说明 |
| ------------------- | --- | ------------ |
| `additionalContext` | 字符串 | 在会话开始时添加的上下文 |
| `modifiedConfig` | 对象 | 替代会话配置 |
### 例子
#### 在启动时添加项目上下文
TypeScript
```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(),
};
},
},
});
```
Python
```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})
```
#### 处理会话恢复
```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;
},
},
});
```
#### 加载用户首选项
```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"),
};
},
},
});
```
## 会话结束钩子 {#session-end}
会话结束时调用`onSessionEnd`钩子。
### 挂钩签名
TypeScript
```typescript
type SessionEndHandler = (
input: SessionEndHookInput,
invocation: HookInvocation
) => Promise
;
```
Python
```python
from copilot.session import SessionEndHookInput
from typing import Callable, Awaitable
SessionEndHandler = Callable[
[SessionEndHookInput, dict[str, str]],
Awaitable[None]
]
```
```python
SessionEndHandler = Callable[
[SessionEndHookInput, dict[str, str]],
Awaitable[SessionEndHookOutput | None]
]
```
Go
```golang
package main
import copilot "github.com/github/copilot-sdk/go"
type SessionEndHandler func(
input copilot.SessionEndHookInput,
invocation copilot.HookInvocation,
) error
func main() {}
```
```golang
type SessionEndHandler func(
input SessionEndHookInput,
invocation HookInvocation,
) (*SessionEndHookOutput, error)
```
.NET
```csharp
public delegate Task
SessionEndHandler(
SessionEndHookInput input,
HookInvocation invocation);
```
Java
```java
import com.github.copilot.rpc.*;
import java.util.concurrent.CompletableFuture;
public class SessionEndSignature {
SessionEndHandler handler = (SessionEndHookInput input, HookInvocation invocation) ->
CompletableFuture.completedFuture(null);
public static void main(String[] args) {}
}
```
```java
@FunctionalInterface
public interface SessionEndHandler {
CompletableFuture
handle(
SessionEndHookInput input,
HookInvocation invocation);
}
```
### 输入
| 领域 | 类型 | 说明 |
| -------------- | ---------- | --------------- |
| `timestamp` | number | 触发挂钩时的 Unix 时间戳 |
| `cwd` | 字符串 | 当前工作目录 |
| `reason` | 字符串 | 会话结束的原因（请参阅下文） |
| `finalMessage` | 字符串 \| 未定义 | 会话中的最后一条消息 |
| `error` | 字符串 \| 未定义 | 会话因错误结束时的错误消息 |
#### 结束原因
| 原因 | 说明 |
| ------------- | ----------- |
| `"complete"` | 会话正常完成 |
| `"error"` | 会话因错误而结束 |
| `"abort"` | 会话已由用户或代码中止 |
| `"timeout"` | 会话超时 |
| `"user_exit"` | 用户显式结束会话 |
### 输出
| 领域 | 类型 | 说明 |
| ---------------- | --------- | ----------- |
| `suppressOutput` | boolean | 抑制最终会话输出 |
| `cleanupActions` | string\[] | 要执行的清理操作列表 |
| `sessionSummary` | 字符串 | 日志记录/分析会话摘要 |
### 例子
#### 跟踪会话指标
TypeScript
```typescript
const sessionStartTimes = new Map
();
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;
},
},
});
```
Python
```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,
})
```
#### 清理资源
```typescript
const sessionResources = new Map