@appaflytech/zeyrek-ai-mcp 0.0.2 → 0.0.4

package/dist/knowledge/styleResolve.js

@@ -0,0 +1,485 @@
+/**
+ * ÖZET — Bir düğümün EFEKTİF stili: tasarımcının ekranda gördüğü sonucun
+ * gateway tarafında yeniden kurulması. `page_runtime_get(resolveStyles: true)`
+ * her düğüme bu modülün ürettiği `resolvedStyle` + `styleLayers`'ı ekler ve
+ * "bu kutu neden böyle görünüyor" sorusu cevaplanabilir olur.
+ *
+ * KATMAN SIRASI (karar K4, 2026-08-30) — tipli stil komponentlerinde:
+ *   tema componentStyles → $preset  = TABAN (varsayılan verir)
+ *   tipli gruplar (panel seçimleri) = ortada (temayı alan alan ezer)
+ *   düğümün serbest `style`'ı       = EN ÜST (kaçış kapısı, son söz)
+ * Tipli olmayan komponentlerde eski birleşik kaskad geçerlidir
+ * (componentStyles → preset → düğüm).
+ *
+ * KAYNAK EŞLEŞMESİ: kaskad `zeyrek-frontend/packages/ng-apps-screen-builder/
+ * src/style-presets.ts`'in, tipli derleme `zeyrek-frontend/packages/ng-apps-ui/
+ * src/style-groups/style-group-compose.ts`'in (aibox bölge uzantısı
+ * `.../components/aibox/aibox-style-logic.ts`) birebir kopyasıdır. Gateway
+ * frontend workspace'ine dahil olmadığı için paket import edilemez; kopyanın
+ * sürüklenmesini `test/style-resolve.test.ts` üç yoldan kilitler: kaynak metin
+ * ipleri, ortak ALTIN vakalar (`style-group-golden.json`) ve `components.json`
+ * ile ALAN pariteleri. Yeni bir komponent tipli gruplara katıldığında buradaki
+ * `TYPED_STYLE_COMPONENTS` kaydına eklenir — başka hiçbir yer değişmez.
+ */
+export const STYLE_PRESET_KEY = '$preset';
+/**
+ * Satır yüksekliği ÜÇ yazımı da kabul eder: oran (1.4), yüzde ('140%') ve CSS
+ * uzunluğu ('24px'). Çıplak sayı ikircikli tek durumdur — eski panel YÜZDE
+ * yazıyordu (140 → 1.4), bu yüzden 4'ten büyük çıplak sayı yüzde sayılır.
+ */
+export const asLineHeight = (value) => {
+    if (!isSet(value))
+        return undefined;
+    const text = String(value).trim();
+    if (!text)
+        return undefined;
+    const numeric = Number(text);
+    if (Number.isFinite(numeric)) {
+        if (numeric <= 0)
+            return undefined;
+        return numeric >= 4 ? numeric / 100 : numeric;
+    }
+    return text;
+};
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export const deepMergeStyle = (base, override) => {
+    const result = { ...base };
+    for (const key in override) {
+        const next = override[key];
+        const current = result[key];
+        result[key] = isPlainObject(current) && isPlainObject(next) ? deepMergeStyle(current, next) : next;
+    }
+    return result;
+};
+export const resolveNodeStyleLayers = (style, source, nodeType) => {
+    const styleObject = isPlainObject(style) ? style : undefined;
+    const { [STYLE_PRESET_KEY]: presetName, ...own } = styleObject ?? {};
+    const componentStyle = nodeType && isPlainObject(source?.componentStyles?.[nodeType]) ? source.componentStyles[nodeType] : undefined;
+    const preset = typeof presetName === 'string' && isPlainObject(source?.presets?.[presetName]) ? source.presets[presetName] : undefined;
+    let theme;
+    if (componentStyle || preset) {
+        theme = deepMergeStyle(componentStyle ?? {}, preset ?? {});
+        delete theme[STYLE_PRESET_KEY];
+    }
+    if (!styleObject && typeof style === 'string' && style)
+        return { theme, own: style };
+    return { theme, own: Object.keys(own).length ? own : undefined };
+};
+export const resolveNodeStyle = (style, source, nodeType) => {
+    if (!isPlainObject(style) && style !== undefined && style !== null)
+        return style;
+    const { theme, own } = resolveNodeStyleLayers(style, source, nodeType);
+    const result = deepMergeStyle(theme ?? {}, isPlainObject(own) ? own : {});
+    return Object.keys(result).length ? result : undefined;
+};
+/* ---- Tipli grup derlemesi (style-group-compose.ts kopyası) ---- */
+// Kademeler tema ölçeğinin token'larıdır (frontend T.1 ile birebir):
+// tema "Border radius"u değişince sm/lg oransal izler, kaynak tek yerdedir.
+const RADIUS_VALUES = {
+    none: '0',
+    sm: 'var(--ng-radius-sm)',
+    md: 'var(--ng-radius-md)',
+    lg: 'var(--ng-radius-lg)',
+    pill: 'var(--ng-radius-pill)'
+};
+const SHADOW_VALUES = {
+    none: 'none',
+    sm: 'var(--ng-shadow-sm)',
+    md: 'var(--ng-shadow-md)',
+    lg: 'var(--ng-shadow-lg)'
+};
+const DEFAULT_DIVIDER_COLOR = 'var(--ng-border-primary)';
+const isUnresolvedExpression = (value) => typeof value === 'string' && value.includes('{{');
+const isSet = (value) => value !== undefined && value !== null && value !== '' && !isUnresolvedExpression(value);
+const asNumber = (value) => {
+    if (!isSet(value))
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+/**
+ * DEĞER MODELİ (K9): boyut alanları CSS METNİ taşır ('18px', '1.2em', '50%');
+ * çıplak sayı px sayılır (eski sayfa toleransı); sıfır ve boşluk "seçilmedi".
+ */
+const asDimension = (value) => {
+    if (!isSet(value))
+        return undefined;
+    if (typeof value === 'number')
+        return Number.isFinite(value) && value !== 0 ? `${value}px` : undefined;
+    const text = String(value).trim();
+    if (!text)
+        return undefined;
+    const numeric = Number(text);
+    // METİN sıfır gerçek seçimdir (bileşenin taban dolgusunu kaldırmanın tek
+    // yolu); yalnız SAYI 0 "seçilmedi" sayılır (eski sayı girdisi toleransı).
+    if (Number.isFinite(numeric))
+        return `${numeric}px`;
+    return text;
+};
+const assign = (target, key, value) => {
+    if (isSet(value))
+        target[key] = value;
+};
+const nest = (target, selector, rules) => {
+    if (!Object.keys(rules).length)
+        return;
+    target[selector] = isPlainObject(target[selector]) ? deepMergeStyle(target[selector], rules) : rules;
+};
+/** `radius` TEK alandır: preset anahtarı ('lg') YA DA CSS uzunluğu ('18px'). */
+const resolveRadius = (value) => {
+    if (!isSet(value))
+        return undefined;
+    return RADIUS_VALUES[value] ?? asDimension(value);
+};
+/**
+ * Gölge TEK alanda iki yazımı taşır: eski preset anahtarı ('md') tema
+ * token'ına çevrilir, geri kalan her şey (çok katmanlı `box-shadow`, `inset`,
+ * `var(--ng-shadow-lg)`) olduğu gibi CSS'e iner.
+ */
+const resolveShadow = (shadow) => {
+    if (!isSet(shadow))
+        return undefined;
+    return SHADOW_VALUES[shadow] ?? String(shadow);
+};
+/**
+ * Grupların alan listeleri — frontend `style-groups/style-group-schemas.ts`
+ * `STYLE_GROUP_FIELDS`'in kopyası. Parite testi `components.json`'daki gerçek
+ * şemayı bu listeyle karşılaştırır: frontend'e eklenen bir alan buraya
+ * yansıtılmazsa test kırmızıya düşer.
+ */
+export const STYLE_GROUP_FIELDS = {
+    surfaceStyle: [
+        'background',
+        'radius',
+        'borderTop',
+        'borderRight',
+        'borderBottom',
+        'borderLeft',
+        'shadow',
+        'contentOverflow'
+    ],
+    typographyStyle: [
+        'textColor',
+        'fontFamily',
+        'fontSize',
+        'fontWeight',
+        'fontStyle',
+        'textDecoration',
+        'lineHeight',
+        'letterSpacing',
+        'textAlign'
+    ],
+    hoverStyle: ['background', 'borderColor', 'shadow', 'lift', 'transitionMs']
+};
+export function composeTypedStyle(input, ext) {
+    const groups = {};
+    if (isPlainObject(input.surfaceStyle)) {
+        const surface = input.surfaceStyle;
+        assign(groups, 'background', surface.background);
+        assign(groups, 'borderRadius', resolveRadius(surface.radius));
+        assign(groups, 'boxShadow', resolveShadow(surface.shadow));
+        // Kenarlık YÖN BAŞINA yazılır (CSS'in `border` kısayolu yön başına değer
+        // taşıyamaz). Hiçbir yön yazılmamışsa EMEKLİ üçlü okunur — kayıtlı
+        // sayfalar bozulmasın diye; bir yön yazıldığı anda takma ad susar.
+        let wroteSide = false;
+        for (const side of ['borderTop', 'borderRight', 'borderBottom', 'borderLeft']) {
+            if (isSet(surface[side])) {
+                groups[side] = surface[side];
+                wroteSide = true;
+            }
+        }
+        if (!wroteSide) {
+            const width = asNumber(surface.borderWidth);
+            if (width !== undefined) {
+                // 0 geçerli bir seçimdir: "çerçeveyi kapat" demektir, atlanamaz.
+                groups.border = width > 0 ? `${width}px ${surface.borderStyle || 'solid'} ${surface.borderColor || DEFAULT_DIVIDER_COLOR}` : 'none';
+            }
+            else if (isSet(surface.borderColor) || isSet(surface.borderStyle)) {
+                groups.border = `1px ${surface.borderStyle || 'solid'} ${surface.borderColor || DEFAULT_DIVIDER_COLOR}`;
+            }
+        }
+        if (isSet(surface.contentOverflow) && ext?.overflowTarget) {
+            nest(groups, ext.overflowTarget, { overflow: surface.contentOverflow });
+        }
+    }
+    if (isPlainObject(input.typographyStyle)) {
+        const typography = input.typographyStyle;
+        assign(groups, 'color', typography.textColor);
+        assign(groups, 'fontFamily', typography.fontFamily);
+        assign(groups, 'textAlign', typography.textAlign);
+        assign(groups, 'fontStyle', typography.fontStyle);
+        assign(groups, 'textDecoration', typography.textDecoration);
+        assign(groups, 'fontSize', asDimension(typography.fontSize));
+        assign(groups, 'letterSpacing', asDimension(typography.letterSpacing));
+        if (isSet(typography.fontWeight))
+            groups.fontWeight = String(typography.fontWeight);
+        const lineHeight = asLineHeight(typography.lineHeight);
+        if (lineHeight !== undefined)
+            groups.lineHeight = lineHeight;
+    }
+    if (isPlainObject(input.hoverStyle)) {
+        const hover = input.hoverStyle;
+        const rules = {};
+        assign(rules, 'background', hover.background);
+        assign(rules, 'borderColor', hover.borderColor);
+        assign(rules, 'boxShadow', resolveShadow(hover.shadow));
+        const lift = asDimension(hover.lift);
+        if (lift !== undefined)
+            rules.transform = `translateY(calc(-1 * ${lift}))`;
+        if (Object.keys(rules).length) {
+            const duration = asNumber(hover.transitionMs) ?? 160;
+            groups.transition = `background-color ${duration}ms ease, border-color ${duration}ms ease, box-shadow ${duration}ms ease, transform ${duration}ms ease`;
+            nest(groups, '&:hover', rules);
+        }
+    }
+    ext?.extra?.(input, groups);
+    // K4: tema tabandır, gruplar üstüne alan alan biner.
+    const themed = isPlainObject(input.themeStyle) ? deepMergeStyle(input.themeStyle, groups) : groups;
+    // Metin `style` çizilemez (designerStyle nesne olmayanı eler); atılır,
+    // tema + gruplar korunur.
+    if (typeof input.style === 'string')
+        return Object.keys(themed).length ? themed : undefined;
+    const merged = isPlainObject(input.style) ? deepMergeStyle(themed, input.style) : themed;
+    return Object.keys(merged).length ? merged : undefined;
+}
+/* ---- aibox'ın komponente özgü uzantısı (aibox-style-logic.ts kopyası) ---- */
+export const HEADER_SECTION_SELECTOR = '& .ng-box-section--header';
+export const FOOTER_SECTION_SELECTOR = '& .ng-box-section--footer';
+const composeAiBoxSections = (input, root) => {
+    if (!isPlainObject(input.sectionStyle))
+        return;
+    const section = input.sectionStyle;
+    const color = section.dividerColor || DEFAULT_DIVIDER_COLOR;
+    const padding = asDimension(section.sectionPadding);
+    const header = {};
+    const footer = {};
+    // `false` "yok say" değil "ayracı kaldır" demektir.
+    if (isSet(section.headerDivider))
+        header.borderBottom = section.headerDivider ? `1px solid ${color}` : 'none';
+    if (isSet(section.footerDivider))
+        footer.borderTop = section.footerDivider ? `1px solid ${color}` : 'none';
+    if (padding !== undefined) {
+        header.padding = padding;
+        footer.padding = padding;
+    }
+    nest(root, HEADER_SECTION_SELECTOR, header);
+    nest(root, FOOTER_SECTION_SELECTOR, footer);
+};
+/* ---- text: emekli prop takma adı (frontend `text-style-logic.ts` kopyası) ---- */
+/** Semantik renk → tema token'ı (`shared/utils.ts` STATUS_COLOR_VAR_MAP kopyası). */
+const STATUS_COLOR_VARS = {
+    primary: '--ng-accent-primary',
+    info: '--ng-status-info',
+    success: '--ng-status-success',
+    warning: '--ng-status-warning',
+    error: '--ng-status-error'
+};
+const isRenderableColorLike = (value) => typeof value === 'string' && /^(#[0-9a-f]{3,8}|rgba?\(|hsla?\(|var\(--)/i.test(value.trim());
+/**
+ * `text`'in EMEKLİ prop'ları (`isBold` / `align` / `color`+`customColor`) kayıtlı
+ * sayfalarda aynı CSS'e iner — yalnız tipli alan BOŞSA; tasarımcı
+ * `typographyStyle`'da o alanı doldurduysa takma ad susar. Gruplardan sonra,
+ * tema birleşiminden önce koşar (tema tabanını ezer, K4).
+ */
+export const applyLegacyTextProps = (input, root) => {
+    if (root.fontWeight === undefined && input.isBold === true)
+        root.fontWeight = '600';
+    if (root.textAlign === undefined && isSet(input.align))
+        root.textAlign = input.align;
+    if (root.color === undefined && isSet(input.color)) {
+        const color = String(input.color);
+        root.color =
+            color === 'custom' && isRenderableColorLike(input.customColor)
+                ? String(input.customColor).trim()
+                : `var(${STATUS_COLOR_VARS[color] ?? STATUS_COLOR_VARS.primary})`;
+    }
+};
+/* ---- container: başlık bölgesi (frontend `container-style-logic.ts` kopyası) ---- */
+const CONTAINER_HEADER_SELECTOR = '&__header';
+const CONTAINER_TITLE_SELECTOR = '&__title';
+/**
+ * `headerStyle` container'a özgü gruptur: başlık metninin rengi/puntosu/
+ * kalınlığı `&__title` parçasına, ayraç ve bölge dolgusu `&__header`
+ * parçasına iner. İkisi de GERÇEK elemandır (SectionHeader onları çizer).
+ */
+export const composeContainerHeader = (input, root) => {
+    const header = input.headerStyle;
+    if (!isPlainObject(header))
+        return;
+    const region = {};
+    const title = {};
+    if (isSet(header.divider)) {
+        region.borderBottom = header.divider ? `1px solid ${header.dividerColor || DEFAULT_DIVIDER_COLOR}` : 'none';
+    }
+    else if (isSet(header.dividerColor)) {
+        region.borderBottom = `1px solid ${header.dividerColor}`;
+    }
+    const padding = asDimension(header.padding);
+    if (padding !== undefined)
+        region.padding = padding;
+    const margin = asDimension(header.margin);
+    if (margin !== undefined)
+        region.margin = margin;
+    const minHeight = asDimension(header.minHeight);
+    if (minHeight !== undefined)
+        region.minHeight = minHeight;
+    if (isSet(header.align))
+        region.alignItems = header.align;
+    if (isSet(header.titleColor))
+        title.color = header.titleColor;
+    const size = asDimension(header.titleSize);
+    if (size !== undefined)
+        title.fontSize = size;
+    if (isSet(header.titleWeight))
+        title.fontWeight = String(header.titleWeight);
+    nest(root, CONTAINER_HEADER_SELECTOR, region);
+    nest(root, CONTAINER_TITLE_SELECTOR, title);
+};
+/**
+ * Tipli stil komponentlerinin kaydı. Yeni bir komponent göçtüğünde buraya bir
+ * satır eklenir: hangi grupları taşıdığı, varsa komponente özgü uzantısı ve
+ * uzantının okuduğu EMEKLİ prop'lar (`legacyProps` — rapor bunları derleyiciye
+ * geçirir ki kayıtlı sayfanın takma adı `resolvedStyle`'da da görünsün).
+ * `resolveNodeStyleReport` tamamen bu kayıttan sürülür.
+ */
+/**
+ * statcard uzantısı — frontend `statcard-style-logic.ts`in aynası.
+ * `valueStyle` gerçek eleman sınıfını hedefler; hizalama ÜÇ kurala çevrilir
+ * (yalnız `text-align` yazmak kontrolü ölü gösterirdi).
+ */
+const STATCARD_FLEX_ALIGN = {
+    left: 'flex-start',
+    center: 'center',
+    right: 'flex-end',
+    justify: 'stretch'
+};
+function composeStatCardParts(input, root) {
+    const value = input.valueStyle;
+    if (isPlainObject(value)) {
+        const target = {};
+        const v = value;
+        if (isSet(v.color))
+            target.color = v.color;
+        if (isSet(v.fontSize))
+            target.fontSize = asDimension(v.fontSize);
+        if (isSet(v.fontWeight))
+            target.fontWeight = v.fontWeight;
+        nest(root, '& .ng-statcard__value', target);
+    }
+    const typography = isPlainObject(input.typographyStyle)
+        ? input.typographyStyle
+        : undefined;
+    if (typography && isSet(typography.textAlign)) {
+        const flex = STATCARD_FLEX_ALIGN[String(typography.textAlign)];
+        if (flex) {
+            nest(root, '& .ng-statcard__main', { alignItems: flex });
+            nest(root, '& .ng-statcard__value-row', { justifyContent: flex });
+        }
+    }
+}
+export const TYPED_STYLE_COMPONENTS = {
+    box: {
+        groups: ['surfaceStyle', 'typographyStyle', 'hoverStyle', 'sectionStyle'],
+        ext: { overflowTarget: '&__body', extra: composeAiBoxSections }
+    },
+    // `aibox` EMEKLİ (K5): tipli modeli box devraldı, kayıtlı düğümler box olarak
+    // çizilir. Kayıt burada kalır ki o düğümlerin resolvedStyle'ı doğru çıksın.
+    aibox: {
+        groups: ['surfaceStyle', 'typographyStyle', 'hoverStyle', 'sectionStyle'],
+        ext: { overflowTarget: '&__body', extra: composeAiBoxSections }
+    },
+    container: {
+        groups: ['surfaceStyle', 'typographyStyle', 'hoverStyle', 'headerStyle'],
+        ext: { overflowTarget: '&__body', extra: composeContainerHeader }
+    },
+    statcard: {
+        groups: ['surfaceStyle', 'typographyStyle', 'hoverStyle', 'valueStyle'],
+        ext: { extra: composeStatCardParts },
+        // Kartın kaydırılan gövdesi yok; taşma alanı ölü kural üretirdi.
+        omit: { surfaceStyle: ['contentOverflow'] }
+    },
+    text: {
+        groups: ['surfaceStyle', 'typographyStyle'],
+        ext: { extra: applyLegacyTextProps },
+        legacyProps: ['isBold', 'align', 'color', 'customColor'],
+        // Taşma hedefi olmayan komponentte contentOverflow ölü kural üretirdi.
+        omit: { surfaceStyle: ['contentOverflow'] }
+    },
+    icon: {
+        // Yalnız hover: surface çipin (chipShape/chipColor), typography da boyutun
+        // (size) ve rengin (color) çift kanalı olurdu — görsel kararlar semantik
+        // prop'larda yaşar (gerekçe komponent şemasında).
+        groups: ['hoverStyle'],
+        // Kökte kenarlık yok; hover'ın borderColor alanı ölü kural üretirdi.
+        omit: { hoverStyle: ['borderColor'] }
+    }
+};
+/** text derlemesi — testler ve dış tüketiciler için sarmalayıcı. */
+export function composeTextStyle(input) {
+    return composeTypedStyle(input, TYPED_STYLE_COMPONENTS.text.ext);
+}
+/** aibox derlemesi — testler ve dış tüketiciler için sarmalayıcı. */
+export function composeAiBoxStyle(input) {
+    return composeTypedStyle(input, TYPED_STYLE_COMPONENTS.aibox.ext);
+}
+/**
+ * Prop zarfını HER SEVİYEDE açar.
+ *
+ * Platform yalnız üst seviyeyi değil, bir prop'un `data`'sının İÇİNİ de
+ * `{ type, data }` zarfıyla saklar. Yalnız üst seviyeyi açmak
+ * `surfaceStyle.borderColor`'ı ham nesne bırakır ve derleme
+ * `1px solid [object Object]` üretir (gerçek sayfada ölçüldü). Frontend'de
+ * aynı işi `mapSchemaPropToRawProp` yapar.
+ */
+const unwrapProp = (value) => {
+    if (Array.isArray(value))
+        return value.map(unwrapProp);
+    if (!isPlainObject(value))
+        return value;
+    if ('data' in value && ('type' in value || 'ref' in value)) {
+        return unwrapProp(value.data);
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value))
+        result[key] = unwrapProp(item);
+    return result;
+};
+const rawProp = (props, name) => {
+    const prop = props?.[name];
+    // İfadeye bağlı prop'un değeri çalışma anında oluşur, burada çözülemez.
+    return prop && typeof prop === 'object' && 'data' in prop ? unwrapProp(prop.data) : undefined;
+};
+/**
+ * Bir düğümün efektif stilini ve hangi katmanların katkı verdiğini döner.
+ * Tipli komponentte K4 sırası (`composeTypedStyle`), diğerlerinde eski
+ * birleşik kaskad uygulanır.
+ */
+export function resolveNodeStyleReport(node, source) {
+    const props = node.props;
+    const ownStyle = rawProp(props, 'style');
+    const config = node.type ? TYPED_STYLE_COMPONENTS[node.type] : undefined;
+    const presetName = isPlainObject(ownStyle) ? ownStyle[STYLE_PRESET_KEY] : undefined;
+    const typedGroups = config ? config.groups.filter(name => isPlainObject(rawProp(props, name))) : [];
+    const layers = {
+        typedGroups,
+        componentStyle: Boolean(node.type && isPlainObject(source?.componentStyles?.[node.type])),
+        preset: typeof presetName === 'string' && presetName ? presetName : null,
+        own: isPlainObject(ownStyle) ? Object.keys(ownStyle).filter(key => key !== STYLE_PRESET_KEY).length > 0 : Boolean(ownStyle)
+    };
+    if (!config) {
+        // Kayıtsız tip: eski birleşik kaskad.
+        const cascaded = resolveNodeStyle(ownStyle, source, node.type);
+        return cascaded === undefined ? { styleLayers: layers } : { resolvedStyle: cascaded, styleLayers: layers };
+    }
+    // Tipli komponent gruplar boşken de tipli yoldan geçer: uzantı emekli
+    // prop'ları okuyabilir (text'in isBold/align/color takma adı) ve K4 sırası
+    // gruplar boşken birleşik kaskadla aynı sonucu verir.
+    const { theme, own } = resolveNodeStyleLayers(ownStyle, source, node.type);
+    const input = { themeStyle: theme, style: own };
+    for (const name of config.groups)
+        input[name] = rawProp(props, name);
+    for (const name of config.legacyProps ?? [])
+        input[name] = rawProp(props, name);
+    const composed = composeTypedStyle(input, config.ext);
+    return composed === undefined ? { styleLayers: layers } : { resolvedStyle: composed, styleLayers: layers };
+}

package/dist/observability/trace.js

@@ -187,6 +187,10 @@ function describeResult(result) {
         : '';
     if (call?.isError)
         return { ok: false, summary: clip(text, 400) };
+    const runtimeErrors = call?.structuredContent?.runtimeErrors;
+    if (Array.isArray(runtimeErrors) && runtimeErrors.length > 0) {
+        return { ok: false, summary: `çalışma anı hatası (platform HTTP 200 döndü): ${clip(runtimeErrors.map(String).join(' | '), 400)}` };
+    }
     const effect = summarizeEffect(text);
     return { ok: true, summary: `${Buffer.byteLength(text, 'utf8')} B yanıt${effect ? ` · ${effect}` : ''}` };
 }

package/dist/platform/http.js

@@ -76,6 +76,9 @@ export class Platform {
             environment: this.resolveEnvironment(options.environment)
         }, true);
     }
+    async accessToken() {
+        return (await this.authorizationHeader()).replace(/^Bearer\s+/i, '');
+    }
     async authorizationHeader() {
         if (this.config.authMode === 'passthrough') {
             const incoming = requestAuthStorage.getStore();

package/dist/platform/responses.js

@@ -14,6 +14,75 @@ export function prune(value) {
     }
     return value;
 }
+/**
+ * Adımın kimliği bir seviye aşağıdadır: `StepOutputDto`'nun `Name` alanı YOKTUR, ad
+ * `steps[].step.name` içinde durur (`WorkflowPreviewDto.cs:40` → `WorkflowStepDto(Guid Id,
+ * string Name, StepType Type)`, satır 93). `hasError`/`errorCode`/`errorMessage` ise üst
+ * seviyededir (satır 43-45).
+ */
+function stepName(node) {
+    const nested = node.step;
+    if (nested && typeof nested === 'object') {
+        const name = nested.name;
+        if (typeof name === 'string' && name !== '')
+            return name;
+    }
+    return typeof node.name === 'string' && node.name !== '' ? node.name : '(adsız adım)';
+}
+/**
+ * İç içe düğümler `hasError` TAŞIMAZ, hep bir `steps[]` dizisine geri döner:
+ * `children` elemanı `ChildStepOutputDto : WorkflowPreviewDto`'dur (`WorkflowPreviewDto.cs:51`
+ * + `:110`), yani kendi `hasError`/`children` alanı yok — gerçek yol
+ * `steps[].children[].steps[].hasError`. `automations` elemanı da `AutomationNodeDto`'dur ve
+ * hatası aynı biçimde `automations[].steps[]` altındadır (`WorkflowPreviewDto.cs:52`, `:135`).
+ */
+function collectStepErrors(nodes, into) {
+    if (!Array.isArray(nodes))
+        return;
+    for (const entry of nodes) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const node = entry;
+        if (node.hasError === true) {
+            const code = typeof node.errorCode === 'string' && node.errorCode !== '' ? node.errorCode : 'bilinmeyen kod';
+            const message = typeof node.errorMessage === 'string' && node.errorMessage !== '' ? `: ${node.errorMessage}` : '';
+            into.push(`${stepName(node)} — ${code}${message}`);
+        }
+        collectStepErrors(node.steps, into);
+        collectStepErrors(node.children, into);
+        collectStepErrors(node.automations, into);
+    }
+}
+/**
+ * Patlayan bir preview/execute HTTP 200 döner; hata gövdenin içinde `steps[].hasError` alanındadır
+ * (WorkflowPreviewDto.cs:38-52). Yanıttaki `executionSuccess` tek başına yeterli değil: platform onu
+ * `Steps.LastOrDefault()?.HasError is false` ile hesaplar (WorkflowPreviewDto.cs:25), yani ortada
+ * patlayıp hata dalından dönen akış `true` üretir. Bu yüzden önce TÜM adımlar taranır.
+ *
+ * Adım taraması yalnız `WorkflowPreviewDto` döndüren uçları kapsar (workflow/automation preview).
+ * Microservice tool'ları `tenantRaw` kullanır ve `http.ts:242` 4xx/5xx'te fırlatmadan
+ * `{ httpStatus, body }` döner; `MicroserviceExecutionItem`'da `hasError` de `steps` de yoktur
+ * (MicroserviceExecutionItem.cs:3-17), yani HTTP 500 ile biten bir çağrı adım taramasına hiç
+ * yakalanmıyordu. Üst seviyedeki `httpStatus` yalnız o raw sarmalından gelir — platform gövdeleri
+ * bu adı hiç kullanmaz (DTO'lar `httpStatusCode` yazar), bu yüzden yanlış pozitif üretmez.
+ */
+export function runtimeErrorSummary(payload) {
+    if (!payload || typeof payload !== 'object')
+        return [];
+    const record = payload;
+    const body = (record.data && typeof record.data === 'object' && !Array.isArray(record.data) ? record.data : record);
+    const errors = [];
+    if (typeof record.httpStatus === 'number' && record.httpStatus >= 400) {
+        errors.push(`httpStatus: ${record.httpStatus} — çağrı ${record.httpStatus} ile bitti; gövde başarı çıktısı değil hata gövdesidir. Adım adım bakmak için microservice_debug kullanın.`);
+    }
+    const stepErrors = [];
+    collectStepErrors(body.steps, stepErrors);
+    if (stepErrors.length === 0 && body.executionSuccess === false) {
+        stepErrors.push('executionSuccess: false — akış başarısız bitti, adım listesinde hata işareti yok');
+    }
+    errors.push(...stepErrors);
+    return errors;
+}
 function findLongestArray(value, best) {
     if (Array.isArray(value)) {
         if (!best.array || value.length > best.array.length)
@@ -57,14 +126,21 @@ function asStructured(payload) {
     return { data: payload };
 }
 export function toolResult(payload, config) {
-    const { payload: bounded, truncated } = shrink(prune(payload), config.maxResponseBytes);
+    const pruned = prune(payload);
+    const runtimeErrors = runtimeErrorSummary(pruned);
+    if (runtimeErrors.length > 0) {
+        logStep('akış hatası ✕', `${runtimeErrors.length} adım hata ile bitti — platform HTTP 200 döndürdüğü için çağrı başarılı görünüyordu`, runtimeErrors);
+    }
+    const { payload: bounded, truncated } = shrink(pruned, config.maxResponseBytes);
     const structured = asStructured(bounded);
     if (truncated) {
         logStep('kırpma ✂', `yanıt ${config.maxResponseBytes} bayt sınırını aştı — en uzun liste yarıya indirilerek küçültüldü (MAX_RESPONSE_BYTES)`);
     }
-    const enriched = truncated
-        ? { ...structured, truncated: true, truncationNote: 'Liste, yanıt boyutu sınırı nedeniyle kırpıldı; sayfalama ya da daha dar filtre kullanın.' }
-        : structured;
+    const enriched = {
+        ...structured,
+        ...(runtimeErrors.length > 0 ? { runtimeErrors } : {}),
+        ...(truncated ? { truncated: true, truncationNote: 'Liste, yanıt boyutu sınırı nedeniyle kırpıldı; sayfalama ya da daha dar filtre kullanın.' } : {})
+    };
     return {
         content: [{ type: 'text', text: JSON.stringify(enriched) }],
         structuredContent: enriched