AI zpracovani textu funguje: klic, adresa a tri skripty

Sluzba byla v katalogu bez pristupovych udaju a s appId 'ai-text', tedy
mirila na aplikaci, ktera neexistuje. Konektor nemel co vyplnit a krok nemel
co vykonat.

- sluzba stoji na api.openai.com/v1 stejne jako OpenAI, overeni GET /models
- model se bere z konektoru (ctx.config.model), ne z kazdeho kroku zvlast
- skripty ai-text.classify, ai-text.extract, ai-text.generate

Proc to neni jedna sluzba s OpenAI: tam se posila volny dotaz a vraci volny
text. Tady je uloha pevna a vystup taky - category a confidence, objekt
s popsanymi poli, text s poctem slov. Na to jde ve strome navazat podminkou,
na volny text ne.

Zjisteno u toho a zapsane do 21-realne-sluzby.md: proxy vraci na neznamou
aplikaci 200 s prazdnym telem, takze overeni konektoru u sluzby bez
verifyPath projde i tam, kde nic nebezi. Zatim neopraveno.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
JiriUhlir
2026-08-28 07:32:18 +02:00
co-authored by Claude Opus 5
parent d71c111cf3
commit aa0a783095
6 changed files with 461 additions and 24 deletions
+106
View File
@@ -0,0 +1,106 @@
/**
* AI zpracovani textu: zarazeni do kategorie.
*
* Sluzba: https://api.openai.com/v1 (nebezi u nas, adresa je v katalogu)
* Endpoint: POST /chat/completions
*
* Rozdil proti sluzbe OpenAI: tam se posila volny dotaz a vraci se volny text.
* Tady je uloha pevna a **vystup taky** - `category` a `confidence`. Prave na
* to se da ve strome navazat podminkou, coz u volneho textu nejde.
*
* Model se bere z konektoru (`ctx.config.model`), aby se nemusel vyplnovat
* u kazdeho kroku znovu.
*/
export const manifest = {
id: 'ai-text.classify',
name: 'Zařadit do kategorie',
description:
'Rozhodne, do které z uvedených kategorií text patří. Vrací kategorii ' +
'a jistotu, takže se za krokem dá větvit podle toho, jak si je model jistý.',
inputs: [
{
id: 'categories',
label: 'Seznam kategorií',
type: 'string',
required: true,
hint: 'Oddělte čárkou, například: porucha, dotaz, reklamace.',
},
{
id: 'text',
label: 'Text',
type: 'string',
required: true,
multiline: true,
hint: 'Co se má zařadit. Typicky předmět a tělo ticketu.',
},
{
id: 'instructions',
label: 'Doplňující pravidla',
type: 'string',
required: false,
multiline: true,
hint: 'Například: reklamací se rozumí jen stížnost na už dodané zboží.',
},
],
outputs: [
{ id: 'category', label: 'Kategorie', type: 'string', required: true },
{ id: 'confidence', label: 'Jistota', type: 'number', required: true },
{ id: 'matched', label: 'Kategorie ze seznamu', type: 'boolean', required: true },
],
timeoutMs: 45000,
};
export async function run(inputs, ctx) {
const { pick, first, text, num, need } = ctx.util;
const categories = inputs.categories
.split(',')
.map((item) => item.trim())
.filter(Boolean);
if (categories.length < 2) ctx.fail('Uveďte aspoň dvě kategorie, jinak není z čeho vybírat.');
const system =
'Jsi klasifikátor. Vrátíš POUZE platný JSON ve tvaru ' +
'{"category": "...", "confidence": 0.0}. Pole category musí být přesně jedna ' +
`z těchto hodnot: ${categories.join(', ')}. Confidence je číslo od 0 do 1.` +
(inputs.instructions ? ` Další pravidla: ${inputs.instructions}` : '');
const { body } = await ctx.http.post('/chat/completions', {
model: ctx.config.model || 'gpt-4o-mini',
messages: [
{ role: 'system', content: system },
{ role: 'user', content: inputs.text },
],
response_format: { type: 'json_object' },
});
const content = text(pick(pick(first(pick(body, 'choices')), 'message'), 'content'));
if (!content) ctx.fail('Model nevrátil odpověď.', body);
let parsed;
try {
parsed = JSON.parse(content);
} catch {
ctx.fail(`Model nevrátil platný JSON: ${content}`);
}
const category = need(text(pick(parsed, 'category')), 'kategorii');
/*
* Model obcas vrati kategorii, ktera v seznamu neni, i kdyz ji ma zakazanou.
* Neni to duvod krok shodit - vysledek se vrati a `matched` rekne, ze je
* mimo seznam. Strom se pak muze rozhodnout, jestli mu verit.
*/
const matched = categories.some((item) => item.toLowerCase() === category.toLowerCase());
if (!matched) ctx.log(`Model vrátil "${category}", což v seznamu není.`);
return {
category,
confidence: num(pick(parsed, 'confidence'), 0) ?? 0,
matched,
};
}
+114
View File
@@ -0,0 +1,114 @@
/**
* AI zpracovani textu: vytazeni udaju.
*
* Sluzba: https://api.openai.com/v1
* Endpoint: POST /chat/completions
*
* Vzor **vystupu, ktery si urcuje uzivatel**. Pole se popisou v kroku stromu
* a model je vrati jako objekt. Manifest je predem znat nemuze, proto se vraci
* jeden parametr typu `object` a vedle nej priznak, co se opravdu naslo.
*
* Nenalezeny udaj je `null`, ne vymysleny. Model, ktery hada, je horsi nez
* model, ktery rekne "nevim" - vymyslene IC se poznat neda.
*/
export const manifest = {
id: 'ai-text.extract',
name: 'Vytáhnout údaje',
description:
'Z volného textu získá strukturovaná data podle polí, která popíšete. ' +
'Co v textu není, vrátí prázdné, nedomýšlí si.',
inputs: [
{
id: 'fields',
label: 'Pole k vytažení',
type: 'string',
required: true,
multiline: true,
hint:
'Jedno pole na řádek ve tvaru nazev: popis. Například:\n' +
'cisloObjednavky: číslo objednávky, obvykle ve tvaru OBJ-1234\n' +
'castka: celková částka v korunách jako číslo',
},
{
id: 'text',
label: 'Text',
type: 'string',
required: true,
multiline: true,
},
],
outputs: [
{ id: 'data', label: 'Vytažené údaje', type: 'object', required: true },
{ id: 'found', label: 'Kolik polí se našlo', type: 'number', required: true },
{ id: 'missing', label: 'Co se nenašlo', type: 'string', required: false },
{ id: 'complete', label: 'Našlo se všechno', type: 'boolean', required: true },
],
timeoutMs: 45000,
};
export async function run(inputs, ctx) {
const { pick, first, text } = ctx.util;
const fields = inputs.fields
.split('\n')
.map((line) => line.trim())
.filter(Boolean)
.map((line) => {
const at = line.indexOf(':');
return at === -1
? { name: line, description: '' }
: { name: line.slice(0, at).trim(), description: line.slice(at + 1).trim() };
})
.filter((field) => field.name !== '');
if (fields.length === 0) ctx.fail('Nepopsali jste žádné pole, takže není co vytáhnout.');
const wanted = fields.map((f) => `- ${f.name}${f.description ? `: ${f.description}` : ''}`);
const system =
'Vytáhni z textu uvedená pole a vrať POUZE platný JSON objekt s přesně těmito klíči:\n' +
`${wanted.join('\n')}\n` +
'Co v textu není, vrať jako null. Nic si nedomýšlej a nic nedopočítávej.';
const { body } = await ctx.http.post('/chat/completions', {
model: ctx.config.model || 'gpt-4o-mini',
messages: [
{ role: 'system', content: system },
{ role: 'user', content: inputs.text },
],
response_format: { type: 'json_object' },
});
const content = text(pick(pick(first(pick(body, 'choices')), 'message'), 'content'));
if (!content) ctx.fail('Model nevrátil odpověď.', body);
let parsed;
try {
parsed = JSON.parse(content);
} catch {
ctx.fail(`Model nevrátil platný JSON: ${content}`);
}
// Vysledek se sklada podle **popsanych poli**, ne podle toho, co model poslal.
// Kdyby si pridal klic navic, strom by o nem nevedel a jen by mu zabiral misto.
const data = {};
const missing = [];
for (const field of fields) {
const value = parsed[field.name];
data[field.name] = value === undefined ? null : value;
if (value === undefined || value === null || value === '') missing.push(field.name);
}
if (missing.length > 0) ctx.log(`Nenašlo se: ${missing.join(', ')}.`);
return {
data,
found: fields.length - missing.length,
missing: missing.length > 0 ? missing.join(', ') : null,
complete: missing.length === 0,
};
}
+114
View File
@@ -0,0 +1,114 @@
/**
* AI zpracovani textu: napsani textu podle instrukce.
*
* Sluzba: https://api.openai.com/v1
* Endpoint: POST /chat/completions
*
* Typicky se z toho stava odpoved zakaznikovi nebo shrnuti do ticketu, takze
* krok umi omezit delku a jazyk. Bez toho model odpovi, jak se mu zachce,
* a odpoved se do e-mailu nebo do komentare nevejde.
*/
export const manifest = {
id: 'ai-text.generate',
name: 'Vygenerovat text',
description:
'Napíše text podle instrukce a vstupních dat. Hodí se na odpověď ' +
'zákazníkovi, shrnutí do ticketu nebo popis incidentu.',
inputs: [
{
id: 'instruction',
label: 'Co má napsat',
type: 'string',
required: true,
multiline: true,
hint: 'Například: Napiš zdvořilou odpověď zákazníkovi, že reklamaci přebíráme.',
},
{
id: 'input',
label: 'Vstupní data',
type: 'string',
required: false,
multiline: true,
hint: 'Text, ze kterého má vycházet. Typicky obsah ticketu.',
},
{
id: 'tone',
label: 'Tón',
type: 'string',
required: false,
options: [
{ value: 'vecny', label: 'Věcný' },
{ value: 'vstricny', label: 'Vstřícný' },
{ value: 'strucny', label: 'Stručný' },
{ value: 'omluvny', label: 'Omluvný' },
],
},
{
id: 'language',
label: 'Jazyk',
type: 'string',
required: false,
default: 'čeština',
hint: 'Bez vyplnění čeština.',
},
{
id: 'maxWords',
label: 'Nejvýše kolik slov',
type: 'number',
required: false,
hint: 'Bez vyplnění rozhoduje model. Do e-mailu se hodí kolem 120.',
},
],
outputs: [
{ id: 'text', label: 'Text', type: 'string', required: true },
{ id: 'words', label: 'Počet slov', type: 'number', required: true },
],
timeoutMs: 60000,
};
const tones = {
vecny: 'Piš věcně a bez zdobení.',
vstricny: 'Piš vstřícně a lidsky, ale ne přehnaně.',
strucny: 'Piš co nejstručněji, ideálně pár vět.',
omluvny: 'Omluv se za potíže, ale neslibuj nic, co není v zadání.',
};
export async function run(inputs, ctx) {
const { pick, first, text, need } = ctx.util;
const rules = [
`Piš v jazyce: ${inputs.language}.`,
inputs.tone ? tones[inputs.tone] : '',
inputs.maxWords !== null ? `Vejdi se do ${inputs.maxWords} slov.` : '',
// Bez tohohle model rad pripoji "Jiste, tady je vas text:" a to jde
// rovnou zakaznikovi do e-mailu.
'Vrať pouze výsledný text, žádný úvod ani komentář k zadání.',
].filter(Boolean);
const { body } = await ctx.http.post('/chat/completions', {
model: ctx.config.model || 'gpt-4o-mini',
messages: [
{ role: 'system', content: rules.join(' ') },
{
role: 'user',
content: inputs.input
? `${inputs.instruction}\n\nVstupní data:\n${inputs.input}`
: inputs.instruction,
},
],
});
const content = need(
text(pick(pick(first(pick(body, 'choices')), 'message'), 'content')),
'vygenerovaný text',
);
return {
text: content,
words: content.split(/\s+/).filter(Boolean).length,
};
}