Erneut mit einem Lektionsplan verbinden

Parameter

Lingara-Versionheaderstringoptional

Die API-Version, unter der diese Anfrage beantwortet wird. Ohne sie erhält ein Zugriffstoken die Version, an die sein Client gebunden ist, und eine Anfrage ohne Token die aktuelle Version. Die Version in Entwicklung ist nur erreichbar, indem man sie hier nennt. Eine unbekannte Version wird mit 400 und dem Code api_version_unknown beantwortet. GET /v1/versions listet die Versionen auf.

idpathstringerforderlich

Antworten

200 Der verbleibende Fortschritt des Plans, dann der Plan

Stream-Ereignisse text/event-stream

Sendet alle 15 Sekunden einen Keepalive-Kommentar.

started PlanStarted

plan_idstringerforderlich

phase PlanPhase

phasestringerforderlich

attemptintegererforderlich

result PlanResult Beendet den Stream

planLessonPlanerforderlich

idstringerforderlich

statusPlanStatuserforderlich

titlestring | nulloptional

source_langstringerforderlich

target_langstringerforderlich

levelintegererforderlich

created_atstringerforderlich

completed_atstring | nulloptional

ai_generatedbooleanerforderlich

contentLessonPlanContent | nulloptional

introductionstring | nulloptional

learning_objectivesarray of stringerforderlich

vocabularyarray of PlanWorderforderlich

wordstringerforderlich

pronunciationstring | nulloptional

translationstringerforderlich

setsarray of PlanSeterforderlich

numberintegererforderlich

contextstring | nulloptional

questionsarray of PlanQuestionerforderlich

typestringerforderlich

promptstringerforderlich

optionsarray of string | nulloptional

answerstringerforderlich

explanationstringerforderlich

hintstring | nulloptional

pending PlanPending Beendet den Stream

plan_idstringerforderlich

statusPlanStatuserforderlich

error StreamError Beendet den Stream

Kommt innerhalb der 200-Antwort an. Die Statuszeile wurde bereits gesendet, daher wird ein Fehler nach dem Öffnen des Streams als dieses Ereignis gemeldet.

codestringerforderlich

messagestringerforderlich

plan_idstring | nulloptional

Fehler

410application/json

Die API-Version, unter der diese Anfrage beantwortet wird, wurde eingestellt. Sende eine unterstützte Version in Lingara-Version oder binde den Client an eine andere Version.

4XXapplication/json

Die Anfrage wurde abgelehnt. code nennt den Grund, und error beschreibt ihn in Worten.

503application/json · text/plain

Der Dienst ist vorübergehend nicht verfügbar; versuche es nach der in Retry-After angegebenen Anzahl Sekunden erneut. Während Wartungsarbeiten ist der Body reiner Text statt des Fehlerumschlags.

5XXapplication/json

Die Anfrage wurde abgelehnt. code nennt den Grund, und error beschreibt ihn in Worten.

codestringerforderlich

Warum die Anfrage abgelehnt wurde, als stabiler Code, nach dem du verzweigen kannst: zum Beispiel insufficient_scope (403), rate_limited (429) und, bei einem nutzungsbasiert abgerechneten Client, spend_cap_reached (402) und metered_billing_inactive (402).

errorstringerforderlich

Beispiel

curl -N "https://api.getlingara.com/v1/lesson-plans/$ID/stream" \
  -H "Authorization: Bearer $LINGARA_TOKEN"

for await (const ev of client.streamLessonPlan({ id: planId })) {
  if (ev.event === "result") console.log("ready:", ev.data.plan.title);
  if (ev.event === "pending") console.log("still", ev.data.status, "- try again later");
}

use lingara::models::StreamLessonPlanEvent;

let mut stream = client.stream_lesson_plan(&plan_id).await?;
while let Some(event) = stream.next().await {
    match event? {
        StreamLessonPlanEvent::Result(result) => println!("ready: {}", result.plan.title.unwrap_or_default()),
        StreamLessonPlanEvent::Pending(pending) => println!("still {:?} - try again later", pending.status),
        _ => {}
    }
}

// Rejoin a plan still generating, with the plan_id from its started event.
s, err := client.StreamLessonPlan(ctx, "3f1c2a9e-5b7d-4e21-9a0c-6d8e4f2b1a37")
if err != nil {
	return err
}
defer s.Close()
for ev, err := range s.Events() {
	if err != nil {
		return err
	}
	switch e := ev.(type) {
	case lingara.StreamLessonPlanEventResult:
		fmt.Println("ready:", e.Data.Plan.ID)
	case lingara.StreamLessonPlanEventPending:
		fmt.Println("still", e.Data.Status, "- rejoin later")
	}
}

import com.getlingara.client.model.StreamLessonPlanEvent;

try (EventStream<StreamLessonPlanEvent> stream = client.streamLessonPlan(planId)) {
  for (StreamLessonPlanEvent event : stream) {
    if (event instanceof StreamLessonPlanEvent.Result result) {
      System.out.println(result.data().getPlan().getTitle());
    } else if (event instanceof StreamLessonPlanEvent.Pending pending) {
      // Still generating elsewhere: ask again later.
      System.out.println("pending: " + pending.data().getStatus());
    }
  }
}

import com.getlingara.kotlin.LingaraClient
import com.getlingara.kotlin.model.StreamLessonPlanEvent

client.streamLessonPlan(planId).use { stream ->
    stream.collect { event ->
        when (event) {
            is StreamLessonPlanEvent.Result -> println(event.data.plan.title)
            // Still generating elsewhere: ask again later.
            is StreamLessonPlanEvent.Pending -> println("pending: ${event.data.status}")
            else -> Unit
        }
    }
}

client.stream_lesson_plan(plan_id) do |event|
  case event
  in Lingara::StreamLessonPlanEventResult => result then puts "ready: #{result.data.plan.title}"
  in Lingara::StreamLessonPlanEventPending => pending then puts "still #{pending.data.status}, try again later"
  else nil
  end
end

use Lingara\Stream\StreamLessonPlanEvent;

foreach ($client->streamLessonPlan($planId) as $event) {
    if ($event instanceof StreamLessonPlanEvent\Result) {
        echo 'ready: ', $event->data->getPlan()->getTitle(), "\n";
    } elseif ($event instanceof StreamLessonPlanEvent\Pending) {
        echo 'still ', $event->data->getStatus()->value, ", try again later\n";
    }
}

Lieber eine Bibliothek? Siehe den Bereich Bibliotheken.

Beispiel-Stream

event: pending
data: {"plan_id":"3f1c2a9e-5b7d-4e21-9a0c-6d8e4f2b1a37","status":"generating"}