Gesendeter Webhook der Benutzeranfrage

Der onUserPromptSubmitted Hook wird aufgerufen, wenn ein Benutzer eine Nachricht sendet. Verwenden Sie es zu folgenden Zwecken:

• Ändern oder Verbessern von Benutzeraufforderungen
• Kontext vor der Verarbeitung hinzufügen
• Filtern oder Überprüfen von Benutzereingaben
• Implementieren von Eingabeaufforderungsvorlagen

Hook-Signatur

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

Die Hook-Signaturen in Python, Go und .NET finden Sie im github/copilot-sdk Repository.

Eingabe

Feld	Typ	Beschreibung
timestamp	Zahl	Unix-Zeitstempel, zu dem der Hook ausgelöst wurde
cwd	Schnur	Aktuelles Arbeitsverzeichnis
prompt	Schnur	Der vom Benutzer übermittelte Prompt

Output

Geben Sie null oder undefined zurück, um die Eingabeaufforderung unverändert zu verwenden. Geben Sie andernfalls ein Objekt mit einem der folgenden Felder zurück.

Feld	Typ	Beschreibung
modifiedPrompt	Schnur	Geänderte Eingabeaufforderung anstelle des Originals
additionalContext	Schnur	Zusätzlicher Kontext zur Unterhaltung hinzugefügt
suppressOutput	boolean	Wenn wahr, unterdrücken Sie die Antwortausgabe des Assistenten.

Beispiele

Protokollieren aller Benutzeraufforderungen

const session = await client.createSession({
  hooks: {
    onUserPromptSubmitted: async (
      input, invocation
    ) => {
      console.log(
        `[${invocation.sessionId}] `
        + `User: ${input.prompt}`
      );
      return null; // Pass through unchanged
    },
  },
});

Beispiele in Python, Go und .NET finden Sie im github/copilot-sdk Repository.

Projektkontext hinzufügen

const session = await client.createSession({
  hooks: {
    onUserPromptSubmitted: async (input) => {
      const projectInfo = await getProjectInfo();

      return {
        additionalContext: `
Project: ${projectInfo.name}
Language: ${projectInfo.language}
Framework: ${projectInfo.framework}
        `.trim(),
      };
    },
  },
});

Erweitern von Kurzbefehlen

const SHORTCUTS: Record<string, string> = {
  "/fix":
    "Please fix the errors in the code",
  "/explain":
    "Please explain this code in detail",
  "/test":
    "Please write unit tests for this code",
  "/refactor":
    "Please refactor this code to improve "
    + "readability and maintainability",
};

const session = await client.createSession({
  hooks: {
    onUserPromptSubmitted: async (input) => {
      for (const [shortcut, expansion]
        of Object.entries(SHORTCUTS)) {
        if (input.prompt.startsWith(shortcut)) {
          const rest = input.prompt
            .slice(shortcut.length).trim();
          return {
            modifiedPrompt:
              `${expansion}`
              + `${rest ? `: ${rest}` : ""}`,
          };
        }
      }
      return null;
    },
  },
});

Inhaltsfilterung

const BLOCKED_PATTERNS = [
  /password\s*[:=]/i,
  /api[_-]?key\s*[:=]/i,
  /secret\s*[:=]/i,
];

const session = await client.createSession({
  hooks: {
    onUserPromptSubmitted: async (input) => {
      for (const pattern of BLOCKED_PATTERNS) {
        if (pattern.test(input.prompt)) {
          return {
            modifiedPrompt:
              "[Content blocked: Please don't "
              + "include sensitive credentials "
              + "in your prompts. Use environment "
              + "variables instead.]",
            suppressOutput: true,
          };
        }
      }
      return null;
    },
  },
});

Erzwingen von Prompt-Längenbegrenzungen

const MAX_PROMPT_LENGTH = 10000;

const session = await client.createSession({
  hooks: {
    onUserPromptSubmitted: async (input) => {
      if (input.prompt.length > MAX_PROMPT_LENGTH) {
        // Truncate the prompt and add context
        return {
          modifiedPrompt: input.prompt.substring(0, MAX_PROMPT_LENGTH),
          additionalContext: `Note: The original prompt was ${input.prompt.length} characters and was truncated to ${MAX_PROMPT_LENGTH} characters.`,
        };
      }
      return null;
    },
  },
});

Hinzufügen von Benutzereinstellungen

interface UserPreferences {
  codeStyle: "concise" | "verbose";
  preferredLanguage: string;
  experienceLevel: "beginner" | "intermediate" | "expert";
}

const session = await client.createSession({
  hooks: {
    onUserPromptSubmitted: async (input) => {
      const prefs: UserPreferences = await loadUserPreferences();
      
      const contextParts = [];
      
      if (prefs.codeStyle === "concise") {
        contextParts.push("User prefers concise code with minimal comments.");
      } else {
        contextParts.push("User prefers verbose code with detailed comments.");
      }
      
      if (prefs.experienceLevel === "beginner") {
        contextParts.push("Explain concepts in simple terms.");
      }
      
      return {
        additionalContext: contextParts.join(" "),
      };
    },
  },
});

Ratenbegrenzung

const promptTimestamps: number[] = [];
const RATE_LIMIT = 10; // prompts
const RATE_WINDOW = 60000; // 1 minute

const session = await client.createSession({
  hooks: {
    onUserPromptSubmitted: async (input) => {
      const now = Date.now();
      
      // Remove timestamps outside the window
      while (promptTimestamps.length > 0 && promptTimestamps[0] < now - RATE_WINDOW) {
        promptTimestamps.shift();
      }
      
      if (promptTimestamps.length >= RATE_LIMIT) {
        return {
          reject: true,
          rejectReason: `Rate limit exceeded. Please wait before sending more prompts.`,
        };
      }
      
      promptTimestamps.push(now);
      return null;
    },
  },
});

Eingabeaufforderungsvorlagen

const TEMPLATES: Record<
  string, (args: string) => string
> = {
  "bug:": (desc) =>
    `I found a bug: ${desc}\n\n`
    + `Please help me:\n`
    + `1. Understand why this is happening\n`
    + `2. Suggest a fix\n`
    + `3. Explain how to prevent similar bugs`,

  "feature:": (desc) =>
    `I want to implement this feature: `
    + `${desc}\n\n`
    + `Please:\n`
    + `1. Outline the implementation approach\n`
    + `2. Identify potential challenges\n`
    + `3. Provide sample code`,
};

const session = await client.createSession({
  hooks: {
    onUserPromptSubmitted: async (input) => {
      for (const [prefix, template]
        of Object.entries(TEMPLATES)) {
        if (
          input.prompt.toLowerCase()
            .startsWith(prefix)
        ) {
          const args = input.prompt
            .slice(prefix.length).trim();
          return {
            modifiedPrompt: template(args),
          };
        }
      }
      return null;
    },
  },
});

Bewährte Methoden

•         **Behalten Sie die Benutzerabsicht bei.** Stellen Sie beim Ändern von Eingabeaufforderungen sicher, dass die Kernabsicht klar bleibt.
  

•         **Seien Sie transparent über Änderungen.** Wenn Sie eine Eingabeaufforderung erheblich ändern, erwägen Sie die Protokollierung oder Benachrichtigung des Benutzers.
  

•         **Verwenden Sie `additionalContext` statt `modifiedPrompt`.** Das Hinzufügen von Kontext ist weniger aufdringlich als das Umschreiben der Eingabeaufforderung.
  

•         **Geben Sie klare Ablehnungsgründe an.** Erläutern Sie beim Ablehnen von Eingabeaufforderungen, warum und wie Sie das Problem beheben können.
  

•         **Sorgen Sie für eine schnelle Verarbeitung.** Dieser Hook wird für jede Benutzernachricht ausgeführt. Vermeiden Sie langsame Vorgänge.
  

Weiterführende Lektüre

•         [AUTOTITLE](/copilot/how-tos/copilot-sdk/use-hooks/quickstart)
  

•         [AUTOTITLE](/copilot/how-tos/copilot-sdk/use-hooks/session-lifecycle)
  

•         [AUTOTITLE](/copilot/how-tos/copilot-sdk/use-hooks/pre-tool-use)