Hook für gesendete Benutzer Prompt

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

In diesem Artikel

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

Hook-Signatur

Codesprachen navigation

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

type UserPromptSubmittedHandler = (
  input: UserPromptSubmittedHookInput,
  invocation: HookInvocation
) => Promise<UserPromptSubmittedHookOutput | null | undefined>;

Eingabe

FeldTypDescription
timestampnumberUnix-Zeitstempel, zu dem der Hook ausgelöst wurde
cwdstringAktuelles Arbeitsverzeichnis
promptstringDer 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:

FeldTypDescription
modifiedPromptstringGeänderte Eingabeaufforderung anstelle des Originals
additionalContextstringZusätzlicher Kontext zur Unterhaltung hinzugefügt
suppressOutputbooleanWenn wahr, unterdrücken Sie die Antwortausgabe des Assistenten.

Beispiele

Protokollieren aller Benutzeraufforderungen

Codesprachen navigation

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

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)) {
          // Replace the prompt with a warning message
          return {
            modifiedPrompt: "[Content blocked: Please don't include sensitive credentials in your prompts. Use environment variables instead.]",
            suppressOutput: true,
          };
        }
      }
      return null;
    },
  },
});

Längenbeschränkungen für Prompts erzwingen

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

Promptvorlagen

const TEMPLATES: Record<string, (args: string) => string> = {
  "bug:": (desc) => `I found a bug: ${desc}

Please help me:
1. Understand why this is happening
2. Suggest a fix
3. Explain how to prevent similar bugs`,

  "feature:": (desc) => `I want to implement this feature: ${desc}

Please:
1. Outline the implementation approach
2. Identify potential challenges
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

  1. Benutzerabsicht beibehalten – Stellen Sie beim Ändern von Eingabeaufforderungen sicher, dass die Kernabsicht klar bleibt.

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

  3. Verwenden Sie additionalContext statt modifiedPrompt – Das Hinzufügen von Kontext ist weniger aufdringlich, als den Prompt umzuschreiben.

  4. Geben Sie klare Ablehnungsgründe an – Wenn Sie Eingabeaufforderungen ablehnen, erläutern Sie, warum und wie sie behoben werden können.

  5. Halten Sie die Verarbeitung schnell – Dieser Hook wird für jede Benutzernachricht ausgeführt. Vermeiden Sie langsame Vorgänge.

Siehe auch