AI
object
%AI
/phlo/resources/AI/AI.phlo
prop
%AI -> model
line 10
Dit item definieert een AI-model met de identificatie 'gpt-5.4-mini'.
'gpt-5.4-mini'const
AI :: engines
line 11
Definieert een mapping van AI-engine-identifiers naar hun respectieve namen, waardoor eenvoudige verwijzing en integratie binnen Phlo-toepassingen mogelijk is.
['claude' => 'Claude', 'gpt' => 'OpenAI', 'chatgpt' => 'OpenAI', 'o1' => 'OpenAI', 'o3' => 'OpenAI', 'o4' => 'OpenAI', 'deepseek' => 'DeepSeek', 'gemini' => 'Gemini', 'grok' => 'Grok']static
AI :: http (string $url, array $headers, bool $json = true, mixed $post = null):string
line 12
Verzendt een HTTP-verzoek naar de opgegeven URL met optionele headers, JSON-payload en POST-gegevens, met de mogelijkheid om de time-outperiode aan te passen.
HTTP($url, $headers, $json, $post, timeout: 300)method
%AI -> resolve (...$args):array
line 13
Bepaalt de AI-engine die moet worden gebruikt op basis van de opgegeven argumenten, met 'OpenAI' als standaard als er geen specifieke engine is opgegeven.
$via = $args['via'] ?? void
unset($args['via'])
$args['model'] ??= $this->model
if ($via) $via = static::engines[strtolower($via)] ?? $via
elseif (isset($args['model'])) $via = static::engines[strtolower(explode(dash, $args['model'])[0])] ?? void
return [$via ?: 'OpenAI', $args]method
%AI -> chat (...$args)
line 21
Deze methode start een chatsessie met de opgegeven AI-engine en argumenten.
[$engine, $args] = $this->resolve(...$args)
return phlo($engine)->chat(...$args)method
%AI -> stream (...$args):Generator
line 25
Stroomt gegevens van een AI-engine met de opgegeven argumenten.
[$engine, $args] = $this->resolve(...$args)
return phlo($engine)->stream(...$args)method
%AI -> embedding (...$args)
line 29
Deze functie lost de engine en argumenten op en roept vervolgens de embedding-methode aan op de opgegeven engine met de meegeleverde argumenten.
[$engine, $args] = $this->resolve(...$args)
return phlo($engine)->embedding(...$args)method
%AI -> vision (...$args)
line 33
Deze functie lost de AI-engine en argumenten op en roept vervolgens de vision-methode van de opgegeven engine aan met de meegeleverde argumenten.
[$engine, $args] = $this->resolve(...$args)
return phlo($engine)->vision(...$args)method
%AI -> transcribe (...$args)
line 37
Transcribeert audio-invoer met behulp van de opgegeven AI-engine en argumenten.
[$engine, $args] = $this->resolve(...$args)
return phlo($engine)->transcribe(...$args)object
%Claude
/phlo/resources/AI/Claude.phlo
const
Claude :: model
line 10
Definieert een model met de 'claude-opus-4-8' bron, die kan worden gebruikt voor verschillende AI-taken binnen Phlo.
'claude-opus-4-8'static
Claude :: context (...$args)
line 12
Initialiseert de context voor Claude door berichten en systeemparameters in te stellen, en zorgt ervoor dat gebruikers- en assistentberichten correct zijn opgemaakt en opgeslagen.
$args['messages'] ??= []
if (isset($args['system'])){
$args['system'] = [['type' => 'text', 'text' => $args['system']]]
}
if (isset($args['assistant']) && array_push($args['messages'], ['role' => 'assistant', 'content' => $args['assistant']])) unset($args['assistant'])
if (isset($args['user']) && array_push($args['messages'], ['role' => 'user', 'content' => $args['user']])) unset($args['user'])
return $argsstatic
Claude :: tool ($tool):array
line 22
Dit maakt een associatieve array aan met de naam en beschrijving van een tool, samen met het invoerschema, dat de eigenschappen en vereiste argumenten voor de tool definieert.
[
'name' => $tool->name,
'description' => $tool->desc,
'input_schema' => [
'type' => 'object',
'properties' => loop($tool->args, fn($data, $arg) => array_filter($data, fn($key) => in_array($key, ['type', 'enum', 'description']), ARRAY_FILTER_USE_KEY)),
'required' => array_keys($tool->args),
],
]method
%Claude -> embedding ($input, $model = 'text-embedding-3-small')
line 32
Genereert een embedding voor de gegeven invoer met behulp van het opgegeven model, standaard 'text-embedding-3-small'.
%OpenAI->embedding($input, $model)method
%Claude -> vision ($text, $image, $stream = false, ...$args)
line 34
Deze functie stuurt een tekst en een afbeelding naar een visiemodel, met de optie om de reactie te streamen of deze in een chatformaat terug te geven.
$data = is_string($image) && str_starts_with($image, 'http') ? file_get_contents($image) : $image
$messages = [['role' => 'user', 'content' => [['type' => 'text', 'text' => $text], ['type' => 'image', 'source' => ['type' => 'base64', 'media_type' => 'image/jpeg', 'data' => base64_encode($data)]]]]]
if ($stream) return $this->stream(...$args, messages: $messages)
else return $this->chat(...$args, messages: $messages)method
%Claude -> chat (...$args)
line 41
Deze functie communiceert met de Claude API om een chatverzoek te verzenden en verwerkt de reactie, waarbij een object wordt geretourneerd met het antwoord, modelinformatie, tokengebruik en eventuele gebruikte tools tijdens de interactie.
$args['model'] ??= static::model
$args['max_tokens'] ??= 4096
$token = $args['token'] ?? null
unset($args['token'])
$args = static::context(...$args)
$res = $this->request('messages', token: $token, POST: $args)
$return = new obj(answer: void, model: $res->model, finish: $res->stop_reason, tokens: ($res->usage->input_tokens ?? 0) + ($res->usage->output_tokens ?? 0), tokens_in: $res->usage->input_tokens ?? 0, tokens_out: $res->usage->output_tokens ?? 0)
$tools = []
foreach ($res->content AS $block){
if ($block->type === 'text') $return->answer = $block->text
elseif ($block->type === 'tool_use') $tools[] = new obj(name: $block->name, args: (array)$block->input)
}
if ($tools) $return->tools = $tools
return $returnmethod
%Claude -> parseSSE (string $url, array $headers, array $payload):Generator
line 58
Parst Server-Sent Events (SSE) van een gegeven URL, verzendt een JSON-payload en beheert reacties, inclusief foutafhandeling en het yielden van gegevens terwijl deze worden ontvangen.
$json = json_encode($payload, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)
$ctx = stream_context_create(['http' => ['method' => 'POST', 'header' => implode(nl, [...$headers, 'Content-Type: application/json', 'Content-Length: '.strlen($json)]), 'content' => $json, 'timeout' => 300, 'ignore_errors' => true]])
$stream = fopen($url, 'r', false, $ctx)
$stream || error('SSE connection failed')
$status = (int)explode(space, $http_response_header[0] ?? 'HTTP/1.1 200')[1]
if ($status >= 400){
$err = json_decode((string)stream_get_contents($stream))
fclose($stream)
error('Claude error '.$status.': '.($err->error->message ?? 'unknown'))
}
$finish = null
$usage = null
while (!feof($stream)){
$line = fgets($stream)
if ($line === false) break
$line = rtrim($line, nl)
if (!str_starts_with($line, 'data:')) continue
$data = ltrim(substr($line, 5))
if ($data === void) continue
$p = json_decode($data)
if (!$p) continue
if (isset($p->error)) error('Claude stream error: '.$p->error->message)
if (($p->type ?? null) === 'message_delta'){
$finish = $p->delta->stop_reason ?? $finish
if (isset($p->usage)) $usage = $p->usage
}
if (($p->type ?? null) === 'content_block_delta' && ($p->delta->type ?? null) === 'text_delta' && isset($p->delta->text)) yield obj(text: $p->delta->text)
}
fclose($stream)
yield obj(done: true, finish: $finish, tokens_in: $usage?->input_tokens, tokens_out: $usage?->output_tokens)method
%Claude -> stream (...$args):Generator
line 90
Streame berichten van de Claude API met behulp van Server-Sent Events (SSE), waardoor real-time interactie met het model mogelijk is.
%res->streaming = true
$args['model'] ??= static::model
$args['max_tokens'] ??= 4096
$token = $args['token'] ?? null
unset($args['token'], $args['cb'])
$args = static::context(...$args)
$args['stream'] = true
if ($token) $headers = ['anthropic-version: 2023-06-01', 'anthropic-beta: oauth-2025-04-20', 'Authorization: Bearer '.$token]
else $headers = ['anthropic-version: 2023-06-01', 'x-api-key: '.%creds->Claude]
return $this->parseSSE('https://api.anthropic.com/v1/messages', $headers, $args)method
%Claude -> request ($uri, ...$args)
line 103
Verstuurt een verzoek naar de Claude API met de opgegeven URI en argumenten, behandelt authenticatie met een token of API-sleutel, en retourneert de gedecodeerde JSON-respons.
$token = $args['token'] ?? null
if ($token) $headers = ['anthropic-version: 2023-06-01', 'anthropic-beta: oauth-2025-04-20', 'Authorization: Bearer '.$token]
else $headers = ['anthropic-version: 2023-06-01', 'x-api-key: '.%creds->Claude]
$res = json_decode(AI::http("https://api.anthropic.com/v1/$uri", $headers, true, $args['POST'] ?? null))
if (isset($res->error)) error('Claude Request error: '.$res->error->message)
return $resobject
%DeepSeek
/phlo/resources/AI/DeepSeek.phlo
const
DeepSeek :: model
line 11
DeepSeek::model is een component die de creatie en het beheer van modellen binnen het DeepSeek-framework vergemakkelijkt, waardoor efficiënte gegevensverwerking en interactie mogelijk is.
'deepseek-chat'const
DeepSeek :: endpoint
line 12
Definieert de eindpunt-URL voor toegang tot de DeepSeek API versie 1.
'https://api.deepseek.com/v1/'const
DeepSeek :: cred
line 13
DeepSeek::cred haalt inloggegevens op voor toegang tot bronnen binnen het DeepSeek-framework.
'DeepSeek'const
DeepSeek :: label
line 14
DeepSeek::label wordt gebruikt om een label te definiëren voor een DeepSeek-resource, wat zorgt voor betere organisatie en identificatie binnen het systeem.
'DeepSeek'method
%DeepSeek -> embedding ($input, $model = 'text-embedding-3-small')
line 16
Genereert een embedding voor de gegeven invoer met behulp van het opgegeven model, standaard ingesteld op 'text-embedding-3-small'.
%OpenAI->embedding($input, $model)object
%Gemini
/phlo/resources/AI/Gemini.phlo
const
Gemini :: model
line 10
Maakt een model in het Gemini-framework, waarmee gegevensstructuren kunnen worden gedefinieerd en gemanipuleerd.
'gemini-2.0-flash'const
Gemini :: endpoint
line 11
Definieert een eindpunt voor toegang tot de Gemini API, waarmee interactie mogelijk is met het opgegeven model op de gegeven URL.
'https://generativelanguage.googleapis.com/v1beta/models/'static
Gemini :: context (...$args)
line 13
Gemini::$context verwerkt invoerargumenten om een gestructureerde context voor een gesprek te creëren, waarbij systeem-, assistent- en gebruikersberichten in een inhoudsarray worden georganiseerd.
$args['contents'] ??= []
if (isset($args['system'])){
$args['systemInstruction'] = ['parts' => [['text' => $args['system']]]]
unset($args['system'])
}
if (isset($args['assistant']) && array_push($args['contents'], ['role' => 'model', 'parts' => [['text' => $args['assistant']]]])) unset($args['assistant'])
if (isset($args['user']) && array_push($args['contents'], ['role' => 'user', 'parts' => [['text' => $args['user']]]])) unset($args['user'])
return $argsstatic
Gemini :: tool ($tool):array
line 24
Gemini::$tool haalt de naam en beschrijving van een tool op, samen met de parameters, die type, eigenschappen en vereiste argumenten omvatten.
[
'name' => $tool->name,
'description' => $tool->desc,
'parameters' => [
'type' => 'object',
'properties' => loop($tool->args, fn($data, $arg) => array_filter($data, fn($key) => in_array($key, ['type', 'enum', 'description']), ARRAY_FILTER_USE_KEY)),
'required' => array_keys($tool->args),
],
]method
%Gemini -> embedding ($input, $model = 'text-embedding-004')
line 34
Genereert embeddings voor de gegeven invoertekst met behulp van het opgegeven model, standaard 'text-embedding-004'.
$this->request($model.':embedContent', POST: ['content' => ['parts' => [['text' => $input]]]])->embedding->valuesmethod
%Gemini -> vision ($text, $image, $stream = false, ...$args)
line 36
Genereert een vision-reactie door tekst en een afbeelding te combineren, met een optionele streamingfunctie voor realtime-uitvoer.
$model = $args['model'] ?? static::model
unset($args['model'])
$contents = [['role' => 'user', 'parts' => [['text' => $text], ['inline_data' => ['mime_type' => 'image/jpeg', 'data' => base64_encode(is_string($image) && str_starts_with($image, 'http') ? file_get_contents($image) : $image)]]]]]
if ($stream) return $this->stream(...$args, model: $model, contents: $contents)
else return $this->chat(...$args, model: $model, contents: $contents)method
%Gemini -> chat (...$args)
line 44
Genereert inhoud op basis van het opgegeven model en argumenten, en retourneert een object dat het gegenereerde antwoord, het gebruikte model, de reden voor beëindiging en details over het tokenverbruik bevat.
$model = $args['model'] ?? static::model
unset($args['model'])
$args = static::context(...$args)
$res = $this->request($model.':generateContent', POST: $args)
$return = new obj(answer: void, model: $model, finish: $res->candidates[0]->finishReason ?? void, tokens: ($res->usageMetadata->promptTokenCount ?? 0) + ($res->usageMetadata->candidatesTokenCount ?? 0), tokens_in: $res->usageMetadata->promptTokenCount ?? 0, tokens_out: $res->usageMetadata->candidatesTokenCount ?? 0)
$tools = []
foreach ($res->candidates[0]->content->parts ?? [] AS $part){
if (isset($part->text)) $return->answer = $part->text
elseif (isset($part->functionCall)) $tools[] = new obj(name: $part->functionCall->name, args: (array)$part->functionCall->args)
}
if ($tools) $return->tools = $tools
return $returnmethod
%Gemini -> parseSSE (string $url, array $headers, array $payload):Generator
line 59
Parst Server-Sent Events (SSE) van een opgegeven URL, verzendt een JSON-payload en verwerkt de respons, waarbij tekstgegevens en gebruiksmetadata worden opgeleverd.
$json = json_encode($payload, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)
$ctx = stream_context_create(['http' => ['method' => 'POST', 'header' => implode(nl, [...$headers, 'Content-Type: application/json', 'Content-Length: '.strlen($json)]), 'content' => $json, 'timeout' => 300, 'ignore_errors' => true]])
$stream = fopen($url, 'r', false, $ctx)
$stream || error('SSE connection failed')
$status = (int)explode(space, $http_response_header[0] ?? 'HTTP/1.1 200')[1]
if ($status >= 400){
$err = json_decode((string)stream_get_contents($stream))
fclose($stream)
error('Gemini error '.$status.': '.($err->error->message ?? 'unknown'))
}
$finish = null
$usage = null
while (!feof($stream)){
$line = fgets($stream)
if ($line === false) break
$line = rtrim($line, nl)
if (!str_starts_with($line, 'data:')) continue
$data = ltrim(substr($line, 5))
if ($data === void) continue
$p = json_decode($data)
if (!$p) continue
if (isset($p->error)) error('Gemini stream error: '.$p->error->message)
if (isset($p->usageMetadata)) $usage = $p->usageMetadata
if ($p->candidates[0]->finishReason ?? null) $finish = $p->candidates[0]->finishReason
$text = $p->candidates[0]->content->parts[0]->text ?? null
if (!is_null($text)) yield obj(text: $text)
}
fclose($stream)
yield obj(done: true, finish: $finish, tokens_in: $usage?->promptTokenCount, tokens_out: $usage?->candidatesTokenCount)method
%Gemini -> stream (...$args):Generator
line 90
Schakelt streaming in voor het opgegeven model in Gemini, bereidt de benodigde argumenten voor en retourneert een geparsed Server-Sent Events antwoord.
%res->streaming = true
$model = $args['model'] ?? static::model
unset($args['model'], $args['cb'])
$args = static::context(...$args)
return $this->parseSSE(static::endpoint.$model.':streamGenerateContent?alt=sse', ['x-goog-api-key: '.%creds->Gemini], $args)method
%Gemini -> request ($path, ...$args)
line 98
Verzendt een verzoek naar de Gemini API op het opgegeven pad met optionele argumenten, behandelt fouten en retourneert de gedecodeerde JSON-respons.
$res = json_decode(AI::http(static::endpoint.$path, ['x-goog-api-key: '.%creds->Gemini], true, $args['POST'] ?? null))
if (isset($res->error)) error('Gemini Request error: '.$res->error->message)
return $resobject
%Grok
/phlo/resources/AI/Grok.phlo
const
Grok :: model
line 11
Grok::model is een component in het Grok-framework die de creatie en het beheer van datamodellen vergemakkelijkt, waardoor eenvoudige interactie met databases en ORM-functionaliteit mogelijk is.
'grok-4'const
Grok :: endpoint
line 12
Definieert een eindpunt voor het doen van API-aanvragen naar de opgegeven URL.
'https://api.x.ai/v1/'const
Grok :: cred
line 13
Grok::cred is een module die functies voor het beheer van inloggegevens biedt binnen het Grok-framework.
'Grok'const
Grok :: label
line 14
Maakt een label voor een Grok-patroon, waardoor betere organisatie en identificatie van patronen in je code mogelijk is.
'Grok'method
%Grok -> embedding ($input, $model = 'text-embedding-3-small')
line 16
Genereert een embedding voor de gegeven invoer met behulp van het opgegeven model, standaard ingesteld op 'text-embedding-3-small'.
%OpenAI->embedding($input, $model)object
%OpenAI
/phlo/resources/AI/OpenAI.phlo
const
OpenAI :: model
line 10
Dit item specificeert het OpenAI-model dat gebruikt moet worden, in dit geval 'gpt-5.4-mini'.
'gpt-5.4-mini'const
OpenAI :: endpoint
line 11
Definieert de endpoint voor toegang tot de OpenAI API, specifiek de basis-URL voor API-verzoeken.
'https://api.openai.com/v1/'const
OpenAI :: cred
line 12
Dit item vertegenwoordigt de OpenAI-referentie die wordt gebruikt voor authenticatie en toegang tot OpenAI-diensten.
'OpenAI'const
OpenAI :: label
line 13
Deze functie wordt gebruikt om gegevens te labelen met behulp van de modellen van OpenAI voor verschillende toepassingen.
'OpenAI'const
OpenAI :: voices
line 14
OpenAI::voices is een vooraf gedefinieerde lijst van stemopties die beschikbaar zijn voor gebruik in Phlo-toepassingen, waaronder 'alloy', 'echo', 'fable', 'onyx', 'nova' en 'shimmer'.
['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer']static
OpenAI :: context (...$args):array
line 15
Deze functie initialiseert de 'messages'-array in de context van OpenAI en voegt systeem-, assistent- en gebruikersberichten toe zoals gespecificeerd in de invoerargumenten.
$args['messages'] ??= []
if (isset($args['system']) && array_unshift($args['messages'], ['role' => 'system', 'content' => $args['system']])) unset($args['system'])
if (isset($args['assistant']) && array_push($args['messages'], ['role' => 'assistant', 'content' => $args['assistant']])) unset($args['assistant'])
if (isset($args['user']) && array_push($args['messages'], ['role' => 'user', 'content' => $args['user']])) unset($args['user'])
return $argsstatic
OpenAI :: tool ($tool):array
line 22
Definieert een functie in OpenAI met gespecificeerde parameters, waaronder type, enum en beschrijving, terwijl strikte validatie van de argumenten wordt afgedwongen.
[
'type' => 'function',
'function' => [
'name' => $tool->name,
'description' => $tool->desc,
'parameters' => [
'type' => 'object',
'properties' => loop($tool->args, fn($data, $arg) => array_filter($data, fn($key) => in_array($key, ['type', 'enum', 'desc']), ARRAY_FILTER_USE_KEY)),
'additionalProperties' => false,
'required' => array_keys($tool->args),
],
'strict' => true,
],
]method
%OpenAI -> chat (...$args):obj
line 36
Deze functie communiceert met de OpenAI API om chatvoltooiingen te genereren op basis van de opgegeven argumenten, en retourneert een object met de responsdetails zoals het gegenereerde antwoord, het gebruikte model en statistieken over het tokengebruik.
$args['model'] ??= static::model
$token = $args['token'] ?? null
unset($args['token'])
$args = static::context(...$args)
$res = $this->request('chat/completions', token: $token, POST: $args)
$return = new obj(answer: $res->choices[0]->message->content, model: $res->model, finish: $res->choices[0]->finish_reason, tokens: $res->usage->total_tokens, tokens_in: $res->usage->prompt_tokens, tokens_out: $res->usage->completion_tokens)
if (isset($res->choices[0]->message->tool_calls)) $return->tools = array_map(fn($tool) => new obj(name: $tool->function->name, args: json_decode($tool->function->arguments, true)), (array)$res->choices[0]->message->tool_calls)
return $returnmethod
%OpenAI -> embedding ($input, $model = 'text-embedding-3-small')
line 46
Genereert een embedding voor de gegeven invoer met behulp van het opgegeven model van OpenAI.
$this->request('embeddings', POST: ['input' => $input, 'model' => $model])->data[0]->embeddingmethod
%OpenAI -> parseSSE (string $url, array $headers, array $payload):Generator
line 47
Stelt een Server-Sent Events (SSE) verbinding tot het opgegeven URL in, verzendt een JSON-payload en headers, en geeft de ontvangen gegevens van de stream terug.
$json = json_encode($payload, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)
$ctx = stream_context_create(['http' => ['method' => 'POST', 'header' => implode(nl, [...$headers, 'Content-Type: application/json', 'Content-Length: '.strlen($json)]), 'content' => $json, 'timeout' => 300, 'ignore_errors' => true]])
$stream = fopen($url, 'r', false, $ctx)
$stream || error('SSE connection failed')
$status = (int)explode(space, $http_response_header[0] ?? 'HTTP/1.1 200')[1]
if ($status >= 400){
$err = json_decode((string)stream_get_contents($stream))
fclose($stream)
error(static::label.' error '.$status.': '.($err->error->message ?? 'unknown'))
}
$finish = null
$usage = null
while (!feof($stream)){
$line = fgets($stream)
if ($line === false) break
$line = rtrim($line, nl)
if (!str_starts_with($line, 'data:')) continue
$data = ltrim(substr($line, 5))
if ($data === '[DONE]' || $data === void) continue
$p = json_decode($data)
if (!$p) continue
if (isset($p->error)) error(static::label.' stream error: '.$p->error->message)
if (isset($p->usage)) $usage = $p->usage
$text = $p->choices[0]->delta->content ?? null
if (!is_null($text)) yield obj(text: $text)
if ($p->choices[0]->finish_reason ?? null) $finish = $p->choices[0]->finish_reason
}
fclose($stream)
yield obj(done: true, finish: $finish, tokens_in: $usage?->prompt_tokens, tokens_out: $usage?->completion_tokens)method
%OpenAI -> stream (...$args):Generator
line 78
Stroomt reacties van de OpenAI API via Server-Sent Events (SSE), waardoor real-time interactie met het model mogelijk is.
%res->streaming = true
$args['model'] ??= static::model
$token = $args['token'] ?? null
unset($args['token'], $args['cb'])
$args = static::context(...$args)
$args['stream'] = true
$bearer = $token ?? %creds->{static::cred};
return $this->parseSSE(static::endpoint.'chat/completions', ['Authorization: Bearer '.$bearer], $args)method
%OpenAI -> transcribe ($file, $model = 'whisper-1', ...$args):obj
line 88
Transcribeert audio van een gegeven bestand met behulp van het opgegeven model en retourneert details zoals duur, taal en getranscribeerde tekst.
if (is_string($file)) $file = new CURLFile($file)
elseif (is_a($file, 'file')) $file = $file->curl
$res = $this->request('audio/transcriptions', false, POST: [...$args, 'model' => $model, 'file' => $file, 'response_format' => 'verbose_json'])
return obj (
model: $model,
duration: $res->duration,
lang: $res->language,
text: $res->text,
)method
%OpenAI -> vision ($text, $image, $stream = false, ...$args):obj
line 99
Deze functie stuurt een tekst en een afbeelding naar het OpenAI vision-model, met de optie om de reactie te streamen of deze in een chatformaat terug te geven.
$args['model'] ??= static::model
$messages = [['role' => 'user', 'content' => [['type' => 'text', 'text' => $text], ['type' => 'image_url', 'image_url' => ['url' => $image]]]]]
if ($stream) return $this->stream(...$args, messages: $messages)
else return $this->chat(...$args, messages: $messages)method
%OpenAI -> request ($uri, $JSON = true, $token = null, ...$args)
line 105
Verzendt een verzoek naar de OpenAI API op de opgegeven URI, met de optie om een JSON-payload en een autorisatietoken op te nemen, en retourneert de gedecodeerde reactie.
$bearer = $token ?? %creds->{static::cred};
$res = json_decode(AI::http(static::endpoint.$uri, ['Authorization: Bearer '.$bearer], $JSON, $args['POST'] ?? null))
if (isset($res->error)) error(static::label.' Request error: '.$res->error->message)
return $resFunctions
function
answer($question, ...$options)
/phlo/resources/AI/answer.phlo line 10
Genereert een kort, direct antwoord op een gegeven vraag, hetzij uit gespecificeerde opties of door een beknopt antwoord te geven zonder extra tekst.
$prompt = 'You are an AI answer machine. '
$prompt .= 'You give short, direct answers without repeating the subject. '
$prompt .= 'You add no explanation, no extra text, and no quotation marks. '
$prompt .= 'Always answer in the same language as the question.'.lf
if ($options){
$prompt .= 'The user asks a question. You choose exactly one of the options below as the answer. '
$prompt .= 'Your answer matches exactly one of the options, with no extra words or punctuation. '
$prompt .= 'If none of the options apply, answer with "-".'.lf.lf
$prompt .= 'Question:'.lf.$question.lf.lf
$prompt .= 'Options:'.lf
$prompt .= implode(lf, $options)
}
else {
$prompt .= 'Give a short and precise answer to the question. '
$prompt .= 'No introduction, no explanation, no list, and no final period.'.lf.lf
$prompt .= 'Question:'.lf.$question
}
$answer = %AI->chat(user: $prompt, temperature: .1)->answer
return $answer === dash ? null : $answer