Acces la modelele AI

DojoCode SDK este conexiunea integrată pe care fiecare proiect DojoCode o primește la serviciile platformei — iar principala sa funcționalitate este accesul la modele AI reale. Proiectul tău poate scrie text, analiza fotografii, picta imagini, anima videoclipuri, compune muzică, vorbi cu o voce clonată și transcrie înregistrări, fără chei API, fără configurare și fără conturi externe.

Îl poți folosi în două moduri:

• Doar întreabă asistentul proiectului. Descrie funcționalitatea în chatul AI al proiectului („adaugă un buton care să transforme promptul meu într-un videoclip scurt”), iar asistentul va scrie cod funcțional pentru șablonul tău.
• Apelează-l singur. SDK-ul este un mic API HTTP. Fiecare șablon are conexiunea injectată automat, iar această pagină conține exemple gata de copiat și lipit pentru fiecare dintre ele.

Funcționalitate Premium

Accesul la modelele AI necesită un abonament premium activ — un plan Premium personal sau calitatea de membru într-o organizație cu un plan plătit. Fiecare generare costă tokeni AI din soldul utilizatorului autentificat care rulează proiectul (vezi Tarife).

Doar pentru proiecte

SDK-ul este disponibil în proiecte — atât în timp ce le editezi, cât și în previzualizarea lor. Nu este disponibil în cadrul provocărilor. Proiectele construite pe șabloanele PGlite, SQLite și Solidity nu au cod de aplicație care să îl poată apela, iar proiectele C și C++ nu îl pot apela încă.

Ce poți construi

Modalitate	Ce face	Încearcă să construiești	Oferit de
text-to-text	Scrie, rezumă, traduce, răspunde, returnează JSON	un generator de chestionare, un scriitor de povești, un explicator de cod	Llama 3 (8B)
image-to-text	Analizează o fotografie și răspunde în text	un identificator de plante, un evaluator de fotografii, un scriitor de text alternativ	GPT-4o mini
text-to-image	Pictează imagini pe baza unei descrieri	un creator de imagini de fundal, un generator de stickere	FLUX schnell
image-to-image	Transformă o fotografie urmând un prompt	„transformă-mi selfie-ul într-o acuarelă”	FLUX dev
text-to-video	Generează un clip video scurt dintr-o descriere	un generator de scene animate	LTX-Video
image-to-video	Animează o imagine statică	„fă acest peisaj să prindă viață”	LTX-Video
text-to-music	Compune o piesă instrumentală	un creator de muzică de fundal pentru jocul tău	MusicGen
text-to-speech	Rostește textul cu o voce clonată	un narator care sună ca tine	Fish Speech
speech-to-text	Transcrie (și traduce) o înregistrare	notițe vocale, subtitrări pentru un clip	Whisper

Modelele din spatele fiecărei modalități se pot schimba pe măsură ce devin disponibile altele mai bune; numele modalităților, intrările și ieșirile de pe această pagină rămân aceleași.

Construiește-l întrebând asistentul

1. Creează un proiect din orice șablon (React, Vue, Next.js, Python, Go, …) sau deschide unul pe care îl ai deja.
2. Deschide panoul AI Chat și descrie funcționalitatea într-un limbaj simplu.
3. Asistentul știe deja cum funcționează SDK-ul în șablonul tău — ce variabile să citească, cum să gestioneze generările lente, cum să afișeze rezultatul — și scrie codul.
4. Folosește funcționalitatea în previzualizare (sau apasă Run pentru șabloanele fără previzualizare).

Fig. 1 - Creează un proiect din orice șablon

Fig. 2 - Descrie funcționalitatea în panoul AI Chat

Fig. 3 - Asistentul construiește aplicația; un clic pe Generate apelează un model AI real

Fig. 4 - Modalitățile lente, cum ar fi muzica, afișează o stare în timp ce rulează, apoi rezultatul

Idei pe care le poți cere:

• „Adaugă o secțiune de studio cu un formular separat pentru text-to-video, image-to-video și text-to-music. Afișează costul estimat, o stare în timp ce rulează și un player la sfârșit.”
• „Permite-mi să încarc o fotografie și să o notez de la 1 la 10 cu o scurtă listă cu ce este bine și ce este rău.”
• „Generează patru modele de stickere din promptul meu și lasă-mă să-l descarc pe cel care îmi place.”
• „Înregistrează-mi vocea, transcrie-o și transform-o într-o listă de activități.”
• „Scrie un chestionar despre subiectul pe care îl tastez, returnat ca JSON, și randează-l sub formă de întrebări cu opțiuni multiple.”

Generările încep doar când dai clic

Previzualizarea îți reîncarcă codul la fiecare salvare, așa că o generare care ar începe la încărcarea paginii te-ar taxa la nesfârșit.

Tarife

Fiecare modalitate are un preț în tokeni AI pe unitate. Opțiunile de cantitate multiplică prețul, iar fiecare unitate începută este taxată integral.

Modalitate	Taxat per	Tokeni AI
text-to-text	cerere	1
image-to-text	cerere	2
speech-to-text	înregistrare	2
text-to-image	imagine (num_outputs)	3
image-to-image	imagine (num_outputs)	5
text-to-speech	1.000 de caractere de text	3
text-to-music	10 secunde de muzică (duration)	4
text-to-video	97 de cadre ≈ 4 secunde de video (length)	12
image-to-video	97 de cadre ≈ 4 secunde de video (length)	12

Exemple:

• 4 imagini din text-to-image → 4 × 3 = 12 tokeni
• 15 secunde de muzică → 2 unități începute × 4 = 8 tokeni; 30 de secunde → 12 tokeni
• Un videoclip de 161 de cadre → 2 unități începute × 12 = 24 de tokeni; cele 97 de cadre implicite → 12 tokeni
• O narațiune de 1.500 de caractere → 2 unități începute × 3 = 6 tokeni

Bine de știut:

• Tokenii sunt taxați în momentul trimiterii generării. Dacă nu ai suficienți, cererea este refuzată și nu se taxează nimic.
• Generările eșuate sunt rambursate automat. Dacă modelul eșuează, tokenii se întorc în soldul tău.
• Ești notificat de fiecare dată. După fiecare generare plătită, o notificare îți spune câți tokeni AI a folosit (sau că au fost rambursați), iar soldul tău de tokeni se actualizează în fiecare tab deschis.
• Prețurile reflectă costul real de rulare al fiecărui model: un videoclip este mult mai scump decât un paragraf de text.

Fig. 5 - O notificare după fiecare generare plătită

Cum funcționează o generare

• Modalitățile rapide (text-to-text, image-to-text, text-to-image, image-to-image, speech-to-text) răspund cu 200 oferind rezultatul final.
• Modalitățile lente (text-to-video, image-to-video, text-to-music, text-to-speech) răspund imediat cu 202 oferind o înregistrare în așteptare; codul tău o interoghează periodic până când este finalizată. Exemplele de pe această pagină fac acest lucru pentru tine.
• Rezultatele media sunt linkuri permanente. Imaginile, videoclipurile și fișierele audio sunt stocate de DojoCode, așa că URL-urile din output continuă să funcționeze — folosește-le direct în <img>, <video> sau <audio>.

Referință API

Credențiale

Platforma injectează două valori în proiectul tău oriunde rulează codul acestuia — un API URL și un token de acces pentru utilizatorul autentificat. Modul în care le citești depinde de șablon; vezi Citirea credențialelor în fiecare șablon. Nu introduce niciodată direct în cod niciuna dintre valori și nu lipi niciodată un token în codul tău.

Fiecare cerere trimite tokenul în antetul Authorization și JSON în corp (body):

POST {API_URL}/ai-generation/generations
Authorization: Bearer {AI_TOKEN}
Content-Type: application/json

{ "modality": "text-to-image", "input": { "prompt": "a watercolor fox in the snow" } }

Endpointuri

Metodă și cale	Ce face
POST /ai-generation/generations	Trimite o generare. Corp (Body): { modality, input, projectId? }. Interogare opțională ?wait=true sau ?wait=false.
GET /ai-generation/generations/{id}	Citește una dintre generările tale — interogheaz-o periodic până se termină.
GET /ai-generation/generations?limit=5	Listează cele mai recente generări ale tale, cele mai noi primele (limit până la 50, filtru opțional status).

wait decide dacă POST menține conexiunea deschisă până când rezultatul este gata:

• Nesetată (implicit): modalitățile rapide așteaptă și răspund cu 200; cele lente răspund imediat cu 202.
• wait=true: menține cererea până când rezultatul este gata (până la aproximativ 90 de secunde), apoi răspunde cu 200. Dacă timpul expiră, răspunde totuși cu 202 — gestionează întotdeauna ambele cazuri.
• wait=false: răspunde imediat cu 202, indiferent de modalitate.

projectId este opțional: transmite ID-ul proiectului tău pentru a asocia notificarea pe care o primești cu proiectul.

Înregistrarea de generare

Fiecare endpoint răspunde cu o înregistrare de generare:

{
  "id": "6aa92938b7c6a66330736b33",
  "status": "succeeded",
  "modality": "text-to-video",
  "model": "lightricks/ltx-video",
  "output": ["https://…/ai-generation-outputs/…/6aa92938b7c6a66330736b33-0.mp4"],
  "outputPersisted": true,
  "error": null,
  "creditsCharged": 12,
  "refunded": false,
  "createdAt": "2026-09-15T11:17:12.898Z",
  "completedAt": "2026-09-15T11:19:01.085Z"
}

Câmp	Semnificație
status	queued sau running în timp ce lucrează; succeeded, failed sau cancelled când este finalizată.
output	Rezultatul: un string pentru text, un URL pentru muzică și voce, o listă de URL-uri pentru imagini și video, un obiect pentru transcriere. null până când reușește.
error	{ message } când a eșuat — afișează mesajul utilizatorului.
creditsCharged	Tokeni AI taxați pentru această generare.
refunded	true când o generare eșuată a returnat tokenii.
outputPersisted	true când conținutul media a fost copiat în spațiul de stocare DojoCode (linkuri permanente).

Erori

Erorile sunt returnate sub forma { name, httpCode, errors: [{ message }] }. Afișează errors[0].message — explică ce a mers greșit într-un limbaj simplu.

Status HTTP	Ce înseamnă	Ce trebuie să faci
400 / 422	Datele de intrare sunt nevalide (câmp lipsă, valoare în afara intervalului, fișier prea mare) sau ai trimis prea multe cereri într-un timp scurt; mesajul spune care dintre ele	Corectează cererea sau așteaptă câteva minute și reîncearcă; nu s-a taxat nimic
401	Tokenul lipsește sau a expirat	Reîncarcă editorul sau previzualizarea pentru a obține o sesiune nouă
403	Nu există un abonament premium activ sau nu sunt suficienți tokeni AI	Fă upgrade sau așteaptă ca tokenii tăi să se reîmprospăteze
404	Generarea respectivă nu există sau nu îți aparține	Verifică id-ul
5xx	Furnizorul de AI a întâmpinat o problemă	Reîncearcă mai târziu

O înregistrare cu status: "failed" conține error.message și refunded: true — tokenii sunt deja înapoi în soldul tău.

Limite

• 30 de generări noi la fiecare 10 minute per utilizator și 600 de citiri de status la fiecare 10 minute (suficient pentru interogare la fiecare 2 secunde).
• Prompturi de până la 4.000 de caractere; text text-to-speech de până la 4.000 de caractere.
• Imagini de intrare de până la 5 MB, fișiere audio de intrare de până la 10 MB, trimise ca URL https sau ca URI de date base64 în corpul JSON (fără încărcări multipart).
• O generare care nu s-a finalizat după 15 minute este anulată și rambursată.

Date de intrare pentru fiecare modalitate

* marchează câmpurile obligatorii. Tot restul este opțional.

Modalitate	Câmpuri de intrare	Output
text-to-text	prompt*, system_prompt, max_tokens (1–4096), temperature (0–2)	string
image-to-text	prompt*, image*	string
text-to-image	prompt*, aspect_ratio, num_outputs (1–4), output_format (webp, jpg, png), output_quality (1–100), seed	listă de URL-uri de imagini
image-to-image	prompt*, image*, prompt_strength (0–1), guidance (0–10), num_inference_steps (1–50), plus opțiunile de la text-to-image	listă de URL-uri de imagini
text-to-video	prompt*, negative_prompt, aspect_ratio, length (9–257 cadre, implicit 97), steps (1–50), cfg (1–20), seed	listă de URL-uri de videoclipuri (MP4)
image-to-video	prompt*, image* (primul cadru), plus opțiunile de la text-to-video	listă de URL-uri de videoclipuri (MP4)
text-to-music	prompt*, duration (1–30 secunde, implicit 8), output_format (mp3, wav), input_audio (o melodie de urmat), seed	un URL audio
text-to-speech	text*, speaker_reference (eșantion de voce de 10–30 s), text_reference (cuvintele rostite în eșantion)	un URL audio
speech-to-text	audio*, language (un cod de limbă sau auto), translate (în engleză), transcription (plain text, srt, vtt)	{ transcription, detected_language, translation, segments }

aspect_ratio acceptă 1:1, 16:9, 21:9, 3:2, 2:3, 4:5, 5:4, 3:4, 4:3, 9:16 și 9:21.

text-to-text

{
  "modality": "text-to-text",
  "input": {
    "prompt": "Write three quiz questions about the solar system as JSON.",
    "system_prompt": "You are a friendly science teacher.",
    "max_tokens": 400,
    "temperature": 0.7
  }
}

image-to-text

{
  "modality": "image-to-text",
  "input": {
    "prompt": "Grade this food plating from 1 to 10 and list what could be better.",
    "image": "data:image/jpeg;base64,/9j/4AAQSkZJRg…"
  }
}

text-to-image

{
  "modality": "text-to-image",
  "input": {
    "prompt": "A cozy reading nook in a treehouse, warm evening light, watercolor",
    "aspect_ratio": "16:9",
    "num_outputs": 2,
    "output_format": "webp"
  }
}

image-to-image

{
  "modality": "image-to-image",
  "input": {
    "prompt": "Turn this photo into a Studio Ghibli style painting",
    "image": "https://example.com/my-photo.jpg",
    "prompt_strength": 0.6
  }
}

text-to-video

{
  "modality": "text-to-video",
  "input": {
    "prompt": "A slow cinematic drone shot over a misty pine forest at sunrise, golden light breaking through the fog, birds flying across the frame",
    "aspect_ratio": "16:9",
    "length": 97
  }
}

image-to-video

{
  "modality": "image-to-video",
  "input": {
    "prompt": "The waves roll gently onto the beach while clouds drift across the sky",
    "image": "https://example.com/beach.jpg"
  }
}

text-to-music

{
  "modality": "text-to-music",
  "input": {
    "prompt": "Upbeat lo-fi hip hop with warm piano chords, soft vinyl crackle and a relaxed drum groove, 85 bpm",
    "duration": 15,
    "output_format": "mp3"
  }
}

text-to-speech

{
  "modality": "text-to-speech",
  "input": {
    "text": "Welcome to my portfolio! Let me show you around.",
    "speaker_reference": "data:audio/webm;base64,GkXfo59ChoEBQveBAULygQRC…",
    "text_reference": "The exact words I said in the voice sample."
  }
}

speech-to-text

{
  "modality": "speech-to-text",
  "input": {
    "audio": "data:audio/webm;base64,GkXfo59ChoEBQveBAULygQRC…",
    "language": "auto",
    "transcription": "plain text"
  }
}

Prompturi mai bune, rezultate mai bune

Modelele video au nevoie de prompturi lungi și descriptive — descrie subiectul, mișcarea, camera și lumina. Pentru text-to-text, cere JSON atunci când vrei date structurate, apoi parsează-l defensiv (modelul îl poate pune într-un bloc de cod).

Intrări media

Câmpurile precum image, audio, input_audio și speaker_reference acceptă un URL https sau un URI de date base64. În browser, transformă mai întâi un fișier selectat sau o înregistrare într-un URI de date:

/** Downscale a picked image to at most 1024 px and return a JPEG data URI (stays under the 5 MB limit). */
export function imageToDataUri(file, maxSide = 1024) {
  return new Promise((resolve, reject) => {
    const img = document.createElement('img');
    img.onload = () => {
      const scale = Math.min(1, maxSide / Math.max(img.width, img.height));
      const canvas = document.createElement('canvas');
      canvas.width = Math.round(img.width * scale);
      canvas.height = Math.round(img.height * scale);
      canvas.getContext('2d').drawImage(img, 0, 0, canvas.width, canvas.height);
      URL.revokeObjectURL(img.src);
      resolve(canvas.toDataURL('image/jpeg', 0.8));
    };
    img.onerror = reject;
    img.src = URL.createObjectURL(file);
  });
}

/** Turn a Blob (for example a MediaRecorder recording) into a data URI. */
export function blobToDataUri(blob) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = () => resolve(reader.result);
    reader.onerror = reject;
    reader.readAsDataURL(blob);
  });
}

Permiterea utilizatorului să aleagă un fișier audio funcționează întotdeauna:

// <input type="file" id="recording" accept="audio/*">
const file = document.querySelector('#recording').files[0];
const result = await generate('speech-to-text', { audio: await blobToDataUri(file) });
console.log(result.transcription);

Înregistrarea de la microfon pentru speech-to-text (sau o mostră de voce pentru text-to-speech):

Accesul la microfon în previzualizare

Panoul de previzualizare din interiorul editorului nu are acces la microfon. Deschide previzualizarea în propria filă de browser (butonul ↗ din bara de adrese a previzualizării) pentru a înregistra, sau oferă un selector de fișiere așa cum este prezentat mai sus.

const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
const recorder = new MediaRecorder(stream, { mimeType: 'audio/webm' });
const chunks = [];

recorder.ondataavailable = (event) => chunks.push(event.data);
recorder.onstop = async () => {
  stream.getTracks().forEach((track) => track.stop());
  const audio = await blobToDataUri(new Blob(chunks, { type: 'audio/webm' }));
  const result = await generate('speech-to-text', { audio });
  console.log(result.transcription);
};

recorder.start();
// …and when the user clicks "Stop":
recorder.stop();

Clonarea vocii necesită o mostră

text-to-speech vorbește cu vocea din mostra pe care o trimiți: include speaker_reference (o înregistrare clară de 10–30 secunde) și text_reference (exact ceea ce se spune în acea înregistrare). Clonează doar voci pe care ai dreptul să le folosești.

Citirea credențialelor în fiecare șablon

Șablon	URL API	Token de acces
React, React TS, Vue, Vue TS, Svelte, SvelteKit, SolidJS, Vanilla JS/TS, Remix, React Native	import.meta.env.VITE_DOJOCODE_API_URL	import.meta.env.VITE_DOJOCODE_AI_TOKEN
Next.js, Next.js TS	process.env.NEXT_PUBLIC_DOJOCODE_API_URL	process.env.NEXT_PUBLIC_DOJOCODE_AI_TOKEN
Astro, Astro TS	import.meta.env.PUBLIC_DOJOCODE_API_URL	import.meta.env.PUBLIC_DOJOCODE_AI_TOKEN
Angular	DOJOCODE_ENV['DOJOCODE_API_URL'] din ./dojocode-env	DOJOCODE_ENV['DOJOCODE_AI_TOKEN']
NestJS, Fastify, Hono, Node.js (previzualizare)	process.env.DOJOCODE_API_URL	process.env.DOJOCODE_AI_TOKEN
Python cu previzualizarea în browser	modulul dojocode_ai (sau os.environ["DOJOCODE_API_URL"])	gestionat de modul (sau os.environ["DOJOCODE_AI_TOKEN"])
Șabloane Run: Python, Node.js, TypeScript, Java, Go, C#, PHP, Ruby, Rust	variabila de mediu DOJOCODE_API_URL	variabila de mediu DOJOCODE_AI_TOKEN

• Fiecare framework expune un prefix diferit pentru codul de browser. Cel greșit este pur și simplu undefined, fără nicio eroare — folosește exact numele din tabel.
• În șabloanele de browser, URL-ul API poate fi o cale proxy de aceeași origine (cum ar fi /dojocode-api) sau un URL complet. Citește-l întotdeauna din variabilă.
• Angular: dojocode-env.ts este creat de platformă lângă app.component.ts și este ascuns în arborele de fișiere — doar importă-l.
• Șabloanele Run primesc, de asemenea, DOJOCODE_PROJECT_ID.
• Nu există niciun fișier .env de creat și niciun pachet de instalat.

Exemple de cod pentru fiecare șablon

Fiecare șablon citește conexiunea în propriul mod (vezi tabelul de mai sus), iar toate exemplele urmează același șablon: un mic helper generate() care trimite cererea, gestionează atât 200 cât și 202, interoghează la fiecare 2 secunde și returnează output — apelat la clicul unui buton.

Un exemplu complet pentru fiecare șablon

Exemple de SDK AI după șablon are un exemplu de copiat și lipit pentru fiecare șablon: React, React TS, Vue, Vue TS, Svelte, SvelteKit, SolidJS, Vanilla JS/TS, Remix, React Native, Next.js, Astro, Angular, NestJS, Fastify, Hono, Node.js, Python (previzualizare în browser și Run), Java, Go, C#, PHP, Ruby și Rust.

Helperul generate()

Helperul pentru șabloanele Vite (React, Vue, Svelte, SolidJS, Vanilla, Remix, React Native). În alte șabloane doar primele două linii se schimbă — citește URL-ul și tokenul cu numele din tabelul de mai sus.

const API_URL = import.meta.env.VITE_DOJOCODE_API_URL;
const API_TOKEN = import.meta.env.VITE_DOJOCODE_AI_TOKEN;
const FINISHED = ['succeeded', 'failed', 'cancelled'];

async function request(path, options = {}) {
  const response = await fetch(`${API_URL}${path}`, {
    ...options,
    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${API_TOKEN}` }
  });
  const data = await response.json().catch(() => null);
  if (!response.ok) throw new Error(data?.errors?.[0]?.message ?? `Request failed (${response.status})`);
  return data;
}

/** Submit a generation and resolve with its output (handles 200 and 202). */
export async function generate(modality, input) {
  let record = await request('/ai-generation/generations', {
    method: 'POST',
    body: JSON.stringify({ modality, input })
  });
  while (!FINISHED.includes(record.status)) {
    await new Promise((resolve) => setTimeout(resolve, 2000));
    record = await request(`/ai-generation/generations/${record.id}`);
  }
  if (record.status !== 'succeeded') throw new Error(record.error?.message ?? 'The generation failed.');
  return record.output;
}

// In a click handler:
const [imageUrl] = await generate('text-to-image', { prompt: 'a watercolor fox in the snow' });

Python în browser: modulul dojocode_ai

Proiectele Python cu previzualizarea în browser primesc un modul gata pregătit în locul codului HTTP:

Funcție	Ce face
await generate_async(modality, input, wait=True, timeout=150)	Trimite o generare și returnează înregistrarea finalizată (un dict). Cu wait=False, returnează imediat înregistrarea în așteptare.
await get_async(generation_id)	Citește o înregistrare de generare.
generate(…), get(…), list_generations(…)	Versiuni sincrone pentru scripturi simple. Acestea îngheață pagina în timp ce așteaptă, așa că generate() așteaptă cel mult 20 de secunde și apoi aruncă DojoCodeAiError cu ID-ul generării — colectează-l mai târziu cu get(id) sau folosește perechea asincronă.
DojoCodeAiError	Aruncată cu mesajul API-ului (lipsă tokenuri, intrare nevalidă, generare eșuată…).

Valorile brute se află și în os.environ["DOJOCODE_API_URL"] și os.environ["DOJOCODE_AI_TOKEN"].

Modulul este instalat în rădăcina proiectului, așa că dojocode_ai.py este un nume de fișier rezervat acolo, iar editorul refuză să creeze unul.

Șabloanele de rulare și regula celor 20 de secunde

Șabloanele fără previzualizare (Python, Node.js, Java, Go, C#, PHP, Ruby, Rust) îți rulează programul într-un container atunci când apeși pe Run, cu DOJOCODE_API_URL, DOJOCODE_AI_TOKEN și DOJOCODE_PROJECT_ID ca variabile de mediu obișnuite.

Regula celor 20 de secunde

O rulare (Run) se oprește după 20 de secunde. Modalitățile rapide (text, imagini, transcriere) se termină la timp — folosește un timeout de client de 15 secunde. Pentru video, muzică și vorbire, trimite cu ?wait=false, verifică periodic (poll) timp de până la ~10 secunde, afișează id-ul generării și citește rezultatul la următoarea rulare cu GET /ai-generation/generations/{id} (sau ?limit=1 pentru cea mai recentă).

C și C++

Proiectele C și C++ nu pot apela încă SDK-ul: mediul lor de rulare (Run) nu are un client HTTPS încorporat. Construiește funcționalități AI folosind unul dintre celelalte șabloane.

Publicarea proiectelor care folosesc SDK-ul

Un proiect al cărui cod apelează SDK-ul nu poate fi publicat pe un site public *.dojocode.net. Apelurile se bazează pe sesiunea autentificată a persoanei care rulează proiectul, așa că un site public fie nu ar funcționa pentru vizitatori, fie ar consuma tokenurile AI ale altcuiva. Când deschizi Publish pe un astfel de proiect, DojoCode listează fișierele care folosesc SDK-ul. Elimină acele apeluri pentru a publica proiectul sau continuă să îl folosești în interiorul DojoCode.

Fig. 6 - Caseta de dialog Publish listează fișierele care apelează SDK-ul

Depanare

Simptom	Soluție
URL-ul sau tokenul este undefined / "credentials not available"	Folosește exact numele variabilei pentru șablonul tău (vezi tabelul de mai sus); framework-urile de browser folosesc fiecare un prefix diferit.
401 după ce editorul a fost deschis pentru o perioadă lungă de timp	Sesiunea a expirat — reîncarcă editorul (sau previzualizarea) și încearcă din nou.
403 "not enough AI tokens"	Așteaptă ca tokenurile tale AI să se reîmprospăteze sau folosește o opțiune mai ieftină (mai puține imagini, un clip mai scurt).
O generare video sau de vorbire rămâne în starea queued/running	Modelele lente pot dura câteva minute la o pornire la rece. Continuă verificarea (polling); după 15 minute, este anulată și rambursată automat.
Sunt taxat cu tokenuri de fiecare dată când salvez	Codul tău pornește o generare la încărcarea paginii (de exemplu, în useEffect). Pornește generările la clicul pe un buton în schimb.
O rulare (Run) se termină fără niciun rezultat	Rulările se opresc după 20 de secunde. Trimite modalitățile lente cu ?wait=false, afișează id-ul și citește-l înapoi la următoarea rulare.
Java: "header parser received no bytes"	Construiește clientul cu HttpClient.Version.HTTP_1_1, ca în exemplu.
Înregistrarea eșuează cu o eroare de permisiune	Panoul de previzualizare al editorului nu are acces la microfon — deschide previzualizarea în propriul tab sau încarcă un fișier audio în schimb.

Ce urmează?

• 📦 Ce sunt proiectele
• 🧩 Șabloane de proiect
• 🧪 Testarea rutelor de server cu API Tester
• 🤖 Asistența AI în provocări