
Återanslut ska hämta fortsättningen på samma körning. Generera igen ska skapa en ny körning. Om båda knapparna startar samma modellanrop kan ett kort nätavbrott ge två svar, två kostnader och en klient som blandar ihop resultatet. Bestäm därför vem som äger körningen innan du lägger till automatiska omförsök.
En anslutning är kortare än en körning
Anta att din app håller på att sammanfatta ett protokoll. Användaren har fått inledningen när mobilen byter nätverk. Det du vet är att anslutningen försvann. Du vet ännu inte om genereringen avbröts, fortsätter på servern eller redan är färdig. Att visa ”försök igen” utan att skilja dessa fall åt gör knappens effekt oklar.
Välj en av två modeller. I den enklare modellen avbryts körningen när anslutningen försvinner och användaren får starta ett nytt svar. I den andra modellen ägs körningen av ett jobb på servern som överlever en prenumerants avbrott. Den modellen behöver lagrat resultat, körningsstatus och ett sätt att läsa fortsättningen. Artikeln handlar om det senare upplägget, som är ett eget applikationskontrakt och inte en egenskap du kan förutsätta hos varje modell-API.
För vanliga timeout- och retryregler runt externa tjänster, börja med API-integrationer med AI. Här är frågan snävare: hur hittar klienten tillbaka till ett redan påbörjat svar utan att skapa ett nytt?
Ge körningen, händelsen och anslutningen olika identiteter
Låt ett körnings-id identifiera det logiska svaret, exempelvis run-a. Inom den körningen får varje sparad händelse ett stigande sekvensnummer. En nätanslutning har däremot bara betydelse för den aktuella överföringen. När nätet återkommer byts anslutningen, medan körnings-id och händelsernas nummer består.
- Körning: användarens begäran att skapa ett visst svar. En uttrycklig ny generering får ett nytt id.
- Händelse: en sparad del av svaret eller ett slutligt statusbesked. Samma återspelade händelse behåller sitt nummer.
- Anslutning: en tillfällig läsare av händelserna. Att ansluta ytterligare en läsare ska inte starta modellen igen.
En möjlig uppdelning är ett skapande anrop som returnerar körnings-id, ett läsande flöde för den körningens händelser och ett statusanrop som kan visa färdigt resultat. Det är ett förslag till din egen backend, inte standardiserade endpoints. Om det skapande anropets svar försvinner behöver även skapandet skyddas med en stabil begäransnyckel, annars kan klienten skapa dubbla jobb redan före prenumerationen.
Last-Event-ID hjälper transporten att ange en position
Med webbläsarens EventSource kan servern sätta ett id på en SSE-händelse. Vid återanslutning skickas den senast registrerade identiteten i Last-Event-ID, enligt HTML-standardens återanslutningsmodell. Det ger servern en position att utgå från. Det skapar däremot ingen historik: din backend måste ha kvar händelserna och kunna översätta positionen till rätt fortsättning.
Behandla inte transportens position som ett kvitto på att användargränssnittet har sparat och visat allt. Om klienten kraschar efter mottagning men före lagring kan den behöva läsa om händelsen. För en ny EventSource-instans efter en sidomladdning behöver appen dessutom återställa körning och position själv. Förvänta dig inte att den gamla instansens minne följer med.
Om du i stället läser ett POST-svar med fetch och en ReadableStream får du inte EventSources automatiska återanslutning genom att bara tolka svaret som SSE. MDN visar hur en läsbar ström konsumeras; val av ny begäran, återspelningsposition och körning hör fortfarande till appens egen logik. Välj transport efter ditt autentiserings- och anropskontrakt, inte efter ett antagande om automatisk återupptagning.
Prova återspelningen utan en modell
Du behöver inte betala för en generering för att undersöka just denna felväg. Spara följande som replay.cjs och kör node replay.cjs med Node.js. Exemplet använder färdigtolkade händelser och en logg i minnet. Det testar konsumtion och återspelning, inte HTTP, SSE-parsning eller ett leverantörs-API.
const assert = require('node:assert/strict');
const run = 'run-a';
const log = [
{ run, seq: 1, type: 'delta', text: 'Hej ' },
{ run, seq: 2, type: 'delta', text: 'från ' },
{ run, seq: 3, type: 'delta', text: 'samma körning.' },
{ run, seq: 4, type: 'done' }
];
const state = { run, cursor: 0, text: '', done: false };
function apply(event) {
if (event.run !== state.run) throw Error('Fel körning');
if (!Number.isSafeInteger(event.seq) || event.seq < 1) throw Error('Ogiltigt id');
if (event.seq <= state.cursor) return;
if (event.seq !== state.cursor + 1) throw Error('Lucka i loggen');
if (state.done) throw Error('Händelse efter slut');
if (event.type === 'delta' && typeof event.text === 'string') state.text += event.text;
else if (event.type === 'done') state.done = true;
else throw Error('Okänd händelse');
state.cursor = event.seq;
}
// Nätet bryts efter två visade delar. Körningen på servern är redan klar.
log.slice(0, 2).forEach(apply);
assert.equal(state.text, 'Hej från ');
assert.equal(state.done, false);
assert.throws(() => apply(log[3]), /Lucka/);
// Vi begär återspelning från sparad cursor. Servern skickar dessutom en dubblett.
[log[1], ...log.filter(e => e.seq > state.cursor)].forEach(apply);
assert.equal(state.text, 'Hej från samma körning.');
assert.equal(state.done, true);
assert.equal(state.cursor, 4);
assert.throws(() => apply({run: 'run-b', seq: 5, type: 'done'}), /Fel körning/);
console.log(state);
console.log('PASS: dubblett, lucka, återspelat slut och fel körning');
Först konsumeras två delar. Sedan försöker exemplet hoppa över en händelse, vilket ska ge ett fel. Efter återanslutningen skickas en redan behandlad del igen, följd av de saknade händelserna och slutbeskedet. Resultatet ska vara texten Hej från samma körning., position 4 och done: true. Sista kontrollen avvisar en händelse från en annan körning. Dessa är exempelvärden, inte uppmätta modellresultat.
Klienten flyttar positionen först när händelsen har behandlats. I en app som sparar lokal vy och position behöver de uppdateras tillsammans; annars kan omladdning ge en position som ligger före den faktiskt sparade texten. Exemplet bygger på en sammanhängande, ordnad sekvens inom en enda körning. Använd det inte oförändrat för flera oberoende kanaler eller händelse-id utan sådan ordning.
Avbrott efter sista textdelen är fortfarande ett avbrott
Texten kan se färdig ut trots att klienten inte har fått slutbeskedet. Spara därför ett uttryckligt slutläge på servern, exempelvis färdig, misslyckad eller avbruten. I miniexemplet finns bara färdigläget. En verklig implementation behöver även de andra terminala utfallen och ska visa dem utan att kalla ett avklippt svar för färdigt.
Om händelseloggen har gallrats får servern inte skicka godtycklig fortsättning som om inget saknades. Välj i stället ett dokumenterat svar: läs en fullständig ögonblicksbild med dess position, eller meddela att återspelning inte längre går. Det är bättre att låta användaren välja en ny generering än att tyst klistra ihop gammal inledning med ett nytt svar.
Återanslutning ska också behörighetskontrolleras. Ett känt körnings-id ger ingen rätt att läsa någon annans text. Kontrollera ägaren vid både statusläsning och prenumeration. Skicka inte modellens verktygsanrop en gång till bara för att deras text visas på nytt; återspelningen ska återge sparade händelser, inte utföra arbetsflödet igen.
Bestäm vad som ska hända när användaren lämnar
En separat körning kräver en uttrycklig avbrytningspolicy. Att stänga flödet kan betyda ”sluta prenumerera” medan en särskild åtgärd betyder ”stoppa jobbet”. Om modellen fortsätter måste du sätta gränser för livslängd, lagring och förbrukning. Om den stoppas måste klienten kunna få veta det när den kommer tillbaka.
Låt kontrollerade API-svar i tester simulera avbrott före första delen, mellan två delar och efter sista textdelen men före slutbeskedet. Lägg till fallet att användaren klickar på återanslut två gånger. Godkänt utfall är samma körnings-id, en enda synlig kopia av varje del och ett entydigt slutläge. Ny generering ska vara ett separat, synligt beslut.
FAQ
Betyder Last-Event-ID att servern kan återuppta ett AI-svar?
Nej. Det anger en position vid EventSources återanslutning. Servern behöver själv ha kvar rätt händelsehistorik och kunna fortsätta samma körning.
Återansluter fetch automatiskt om jag läser SSE från ett POST-svar?
Nej. Att läsa svaret som en ström ger inte EventSources automatiska återanslutning. Appen behöver själv bestämma nästa begäran, position och körning.
Hur undviker jag dubbla textdelar efter ett avbrott?
Behåll samma körnings-id och stabila händelse-id vid återspelning. Behandla varje del en gång och flytta positionen först när delen har behandlats. Kodexemplet förutsätter en ordnad sekvens utan luckor.
Kan ett AI-svar vara färdigt när klienten saknar slutbeskedet?
Ja, serverns körning kan vara färdig trots att slutbeskedet inte nådde klienten. Läs återspelningen eller serverns sparade slutläge innan du markerar svaret som färdigt.
Kontrollerade 18 november 2026. WHATWG: Server-sent events beskriver EventSource, händelse-id och återanslutning. MDN: Using readable streams beskriver läsning av strömmar. Körningsmodellen, återspelningskontraktet och kodprovet är artikelns egna exempel.