Eine API. Dein gesamter Medien-Workflow.

# Bash-Beispiele: curl + jq; OKTA_API_KEY sicher in der Umgebung setzen.
: "${OKTA_API_KEY:?Bitte zuerst OKTA_API_KEY setzen}"
BASE_URL="https://okta.studio"
ENDPOINT="openai/gpt-image-2.5/flare/text-to-image"

curl --fail-with-body -sS "$BASE_URL/api/v1/fal/models" \
  -H "Authorization: Bearer $OKTA_API_KEY" | jq .

curl --fail-with-body -sS --get "$BASE_URL/api/v1/fal/schema" \
  -H "Authorization: Bearer $OKTA_API_KEY" \
  --data-urlencode "endpoint_id=$ENDPOINT" | jq .input_schema

# Datei und Quote aufbewahren; noch keine Generierung.
cat > input.json <<'JSON'
{
  "prompt": "Ein Produktfoto einer Keramiktasse auf hellem Holz, weiches Tageslicht.",
  "image_size": {
    "width": 1024,
    "height": 1024
  },
  "quality": "medium",
  "num_images": 1,
  "output_format": "png"
}
JSON

jq -n --arg endpoint_id "$ENDPOINT" --slurpfile input input.json \
  '{endpoint_id: $endpoint_id, input: $input[0]}' > quote-request.json

curl --fail-with-body -sS "$BASE_URL/api/v1/fal/quote" \
  -H "Authorization: Bearer $OKTA_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @quote-request.json > quote.json
jq '{credits, currency, reference_quote_id, expires_at}' quote.json

# BEZAHLTER SCHRITT: Quote prüfen und das Budget selbst festlegen.
MAX_CREDITS=20  # Beispiel-Obergrenze, kein versprochener Bildpreis.
# Pro neuem Auftrag einmal vergeben und VOR dem Absenden speichern.
OPERATION_ID="produktmotiv-20260910-001"
printf '%s\n' "$OPERATION_ID" > operation-id.txt

curl --fail-with-body -sS "$BASE_URL/api/v1/fal/queue/$ENDPOINT" \
  -H "Authorization: Bearer $OKTA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $OPERATION_ID" \
  -H "X-Okta-Max-Credits: $MAX_CREDITS" \
  --data-binary @input.json > submitted.json
jq '{request_id, status_url, response_url, context_url, web_url, okta}' submitted.json

# Nach Annahme nur noch diesen Auftrag abfragen, nicht neu starten.
STATUS_URL=$(jq -er '.status_url' submitted.json)
RESULT_URL=$(jq -er '.response_url' submitted.json)
CONTEXT_URL=$(jq -er '.context_url' submitted.json)

curl --fail-with-body -sS "$STATUS_URL" \
  -H "Authorization: Bearer $OKTA_API_KEY" | jq .
# Alle 3–5 Sekunden prüfen. Erst bei COMPLETED ohne error/error_type:
curl --fail-with-body -sS "$RESULT_URL" \
  -H "Authorization: Bearer $OKTA_API_KEY" > result.json
curl --fail-with-body -sS "$CONTEXT_URL" \
  -H "Authorization: Bearer $OKTA_API_KEY" | jq .
# web_url in submitted.json öffnet denselben Auftrag im OKTA-Chat.

# Codex
codex mcp add okta --url https://okta.studio/api/mcp
codex mcp login okta

# Claude Code
claude mcp add --transport http okta https://okta.studio/api/mcp
# danach in Claude Code: /mcp → okta → Authenticate

# In ~/.codex/config.toml ergänzen:
[mcp_servers.okta]
url = "https://okta.studio/api/mcp"
bearer_token_env_var = "OKTA_API_KEY"

{
  "mcpServers": {
    "okta": {
      "type": "http",
      "url": "https://okta.studio/api/mcp",
      "headers": {
        "Authorization": "Bearer ${OKTA_API_KEY}"
      }
    }
  }
}

# Agent Kit 0.5.3 entpacken; kein npm-Install nötig.
# OKTA_API_KEY im Agent-Prozess sicher bereitstellen.
# Optional: OKTA_WORKSPACE nur auf den explizit freigegebenen Medienordner setzen.
node /ABSOLUTER/PFAD/okta-agent-kit/server/stdio.mjs

# Für Plugin-Clients ist okta-agent-kit/ selbst die Plugin-Wurzel.
# Dessen mcp.json nutzt den gehosteten Server mit Browser-Login;
# den lokalen Server trägst du für Dateizugriff selbst ein.

# Agent Kit herunterladen und lokal entpacken (kein npm-Publish nötig).
curl --fail-with-body -sS https://okta.studio/downloads/okta-agent-kit \
  -o okta-agent-kit.zip
unzip okta-agent-kit.zip
CLI="okta-agent-kit/skills/okta-cli/scripts/okta-cli.mjs"

node "$CLI" --json skills list
node "$CLI" --json skills show --id product-photoshoot
node "$CLI" fal models --query gpt-image-2.5
node "$CLI" fal schema --endpoint "$ENDPOINT"
node "$CLI" fal quote --endpoint "$ENDPOINT" --input-file input.json
# Erst nach Preisprüfung; dieselbe gespeicherte ID bei Wiederholung verwenden:
node "$CLI" fal submit --endpoint "$ENDPOINT" --input-file input.json \
  --idempotency-key "$OPERATION_ID" --max-credits "$MAX_CREDITS"

# h3-input.json anhand des aktuellen input_schema erstellen; 768P verwenden.
H3_ENDPOINT="minimax/h3-max/reference-to-video"
jq -n --arg endpoint_id "$H3_ENDPOINT" --slurpfile input h3-input.json \
  '{endpoint_id: $endpoint_id, input: $input[0]}' > h3-quote-request.json
curl --fail-with-body -sS "$BASE_URL/api/v1/fal/quote" \
  -H "Authorization: Bearer $OKTA_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @h3-quote-request.json > h3-quote.json
jq '{credits, reference_quote_id, expires_at}' h3-quote.json

# Erst nach Freigabe des gemessenen Preises:
REFERENCE_QUOTE=$(jq -er '.reference_quote_id' h3-quote.json)
: "${H3_MAX_CREDITS:?Gemessenes Budget selbst freigeben}"
: "${H3_OPERATION_ID:?Neue stabile H3-Auftrags-ID vorher speichern}"
curl --fail-with-body -sS "$BASE_URL/api/v1/fal/queue/$H3_ENDPOINT" \
  -H "Authorization: Bearer $OKTA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $H3_OPERATION_ID" \
  -H "X-Okta-Max-Credits: $H3_MAX_CREDITS" \
  -H "X-Okta-Reference-Quote: $REFERENCE_QUOTE" \
  --data-binary @h3-input.json

// Node.js / Server, nicht mit einem geheimen Key im Browser ausführen.
// Installation: npm install @fal-ai/client@1.10.1
import { createFalClient } from '@fal-ai/client';

const apiKey = process.env.OKTA_API_KEY;
const operationId = process.env.OKTA_OPERATION_ID; // Vorher speichern!
const maxCredits = Number(process.env.OKTA_MAX_CREDITS);
if (!apiKey || !operationId || !/^[a-zA-Z0-9_.:-]{8,160}$/.test(operationId)
    || !process.env.OKTA_MAX_CREDITS || !Number.isSafeInteger(maxCredits)
    || maxCredits < 0) throw new Error('Key, Auftrags-ID und Budget fehlen/ungültig.');
const proxy = 'https://okta.studio/api/fal/proxy';
const transport = globalThis.fetch;
const fal = createFalClient({
  credentials: () => undefined, // Kein FAL_KEY beim Kunden.
  proxyUrl: { url: proxy, when: 'always' },
  fetch: async (url, init) => {
    if (String(url) !== proxy) throw new Error('Direkter Providerzugriff gesperrt.');
    const headers = new Headers(init?.headers);
    headers.set('Authorization', 'Bearer ' + apiKey);
    return transport(url, { ...init, headers, redirect: 'error' });
  },
});
const endpoint = 'openai/gpt-image-2.5/flare/text-to-image';
// Dieselben Eingaben vorher über /api/v1/fal/quote prüfen.
const submitted = await fal.queue.submit(endpoint, {
  input: {
    "prompt": "Ein Produktfoto einer Keramiktasse auf hellem Holz, weiches Tageslicht.",
    "image_size": {
      "width": 1024,
      "height": 1024
    },
    "quality": "medium",
    "num_images": 1,
    "output_format": "png"
  },
  headers: {
    'Idempotency-Key': operationId,
    'X-Okta-Max-Credits': String(maxCredits),
  },
});
console.log(submitted.request_id); // Dauerhaft speichern.
// In späteren Aufrufen mit dieser ID: fal.queue.status / fal.queue.result.
// Bei einem Submit-Timeout dieselbe ID + Eingaben wiederverwenden.

# Lokale Datei: Multipart über die gemeinsame Mediathek (kleine Dateien).
curl --fail-with-body -sS "$BASE_URL/api/v1/assets" \
  -H "Authorization: Bearer $OKTA_API_KEY" \
  -F "file=@produkt.png" | jq .

# Bereits gespeicherte Medien suchen:
curl --fail-with-body -sS --get "$BASE_URL/api/v1/assets" \
  -H "Authorization: Bearer $OKTA_API_KEY" \
  --data-urlencode 'search=produkt' | jq .

# Beispiel: eigenen Asset-Pfad ersetzen; keine beliebige Fremd-URL.
curl --fail-with-body -sS "$BASE_URL/api/v1/fal/upload" \
  -H "Authorization: Bearer $OKTA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"/api/v1/assets/DEINE_ASSET_ID/content"}'
# Antwort: url, asset_id, content_type, reused.

# Beispiel lädt das erste GPT-Bild. Für Batches alle images[] verarbeiten.
ASSET_URL=$(jq -er '.images[0].url' result.json)
# Authorization niemals an fremde Hosts oder Redirects weitergeben.
case "$ASSET_URL" in
  "$BASE_URL/api/v1/assets/"*/content) ;;
  *) printf '%s\n' 'Kein bestätigter OKTA-Downloadpfad' >&2; exit 1 ;;
esac
curl --fail-with-body -sS "$ASSET_URL" \
  -H "Authorization: Bearer $OKTA_API_KEY" -o ergebnis.png

# Bestehende kompakte API: NICHT das native Eingabeformat.
curl --fail-with-body -sS "$BASE_URL/api/v1/generate/image" \
  -H "Authorization: Bearer $OKTA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.5-flare",
    "prompt": "Ein Produktfoto einer Keramiktasse",
    "settings": { "width": 1024, "height": 1024, "quality": "medium" }
  }'