@appaflytech/zeyrek-ai-mcp 0.0.5 → 0.0.7

package/dist/platform/http.js

@@ -5,6 +5,17 @@ import { TokenProvider } from './token.js';
 import { randomUUID } from 'node:crypto';
 import { request } from 'undici';
 export const requestAuthStorage = new AsyncLocalStorage();
+const hiddenResponseHeaders = new Set(['set-cookie', 'authorization', 'proxy-authorization']);
+/**
+ * Sayfalı tablo akışları `Total-Count` header'ına bağlı ama execute ailesi yalnız gövdeyi
+ * döndürüyordu; sözleşme hiçbir tool'dan doğrulanamıyordu (İK koşusu M-8). Gizli header'lar
+ * her koşulda elenir.
+ */
+export function responseHeadersForTool(raw) {
+    return Object.fromEntries(Object.entries(raw)
+        .map(([name, value]) => [name.toLowerCase(), Array.isArray(value) ? value.join(', ') : value])
+        .filter((entry) => typeof entry[1] === 'string' && !hiddenResponseHeaders.has(entry[0])));
+}
 function buildMultipart(parts, boundary) {
     const chunks = [];
     for (const part of parts) {
@@ -70,6 +81,18 @@ export class Platform {
         });
         return outcome.body;
     }
+    /**
+     * `tenant` gibi davranır (4xx/5xx atar) ama yanıt başlıklarını da verir. `tenantRaw` bu iş için
+     * kullanılamaz: o hata durumunda atmaz, yani satır yazma yolunda 400'ü başarı gibi döndürürdü.
+     * Satır araçları başlığa bakmak zorunda — `X-Unmapped-Members` platformun `localizations`
+     * alanını tanımadığını söyleyen tek işaret (sözleşme D6, gateway eski platformda companion'a düşer).
+     */
+    async tenantWithHeaders(method, project, path, options = {}) {
+        return this.send('tenant', method, `/${this.resolveProject(project)}${path}`, {
+            ...options,
+            environment: this.resolveEnvironment(options.environment)
+        });
+    }
     async tenantRaw(method, project, path, options = {}) {
         return this.send('tenant', method, `/${this.resolveProject(project)}${path}`, {
             ...options,
@@ -95,12 +118,17 @@ export class Platform {
         const url = new URL(`${baseUrl}${path}`);
         appendQuery(url, options.query);
         const callerHeaders = Object.fromEntries(Object.entries(options.headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]));
+        const authorization = callerHeaders.authorization ?? (options.anonymous ? undefined : await this.authorizationHeader());
         const headers = {
             host: `${this.config.organization}.${this.config.hostSuffix}`,
             accept: 'application/json',
-            ...(callerHeaders.authorization || options.anonymous ? {} : { authorization: await this.authorizationHeader() }),
+            ...(authorization === undefined ? {} : { authorization }),
             ...(options.environment ? { 'x-environment': options.environment } : {}),
-            ...callerHeaders
+            ...callerHeaders,
+            'x-client': 'mcp',
+            ...(options.mirrorAuthorizationCookie && authorization !== undefined && callerHeaders.cookie === undefined
+                ? { cookie: `NG_AccessToken=${authorization.replace(/^Bearer /, '')}` }
+                : {})
         };
         let body;
         if (options.multipart) {
@@ -127,6 +155,7 @@ export class Platform {
         let statusCode;
         let payload;
         let responseBytes = 0;
+        let responseHeaders = {};
         try {
             const response = await request(url, {
                 method: method,
@@ -135,6 +164,7 @@ export class Platform {
                 signal: AbortSignal.timeout(this.config.requestTimeoutMs)
             });
             statusCode = response.statusCode;
+            responseHeaders = responseHeadersForTool(response.headers);
             if (options.expectBinary && statusCode < 400) {
                 const bytes = Buffer.from(await response.body.arrayBuffer());
                 responseBytes = bytes.byteLength;
@@ -164,9 +194,9 @@ export class Platform {
             return this.send(api, method, path, options, raw, true);
         }
         if (raw)
-            return { httpStatus: statusCode, body: payload ?? null };
+            return { httpStatus: statusCode, body: payload ?? null, headers: responseHeaders };
         if (statusCode >= 400)
             throw mapPlatformError(statusCode, payload, context);
-        return { httpStatus: statusCode, body: payload ?? { success: true } };
+        return { httpStatus: statusCode, body: payload ?? { success: true }, headers: responseHeaders };
     }
 }

package/dist/platform/patch.js

@@ -0,0 +1,27 @@
+export function patchResult(response, fallback) {
+    const envelope = response && typeof response === 'object'
+        ? (response.data ?? response)
+        : {};
+    const written = envelope.data && typeof envelope.data === 'object'
+        ? envelope.data
+        : fallback;
+    return {
+        // Sayı olarak gelen bir newVersion JSON.parse sırasında ZATEN yuvarlanmıştır
+        // (6.4e16 > MAX_SAFE_INTEGER): geri gönderilirse her patch 409 verir, boş bırakmak dürüst.
+        newVersion: typeof envelope.newVersion === 'string' ? envelope.newVersion : '',
+        applied: typeof envelope.applied === 'number' ? envelope.applied : 0,
+        data: written
+    };
+}
+/**
+ * `baseVersion` PATCH gövdesinde ZORUNLU. Okunan kayıtta `version` yoksa platform 422 döndürür;
+ * ajanın hatayı gateway'e değil eksik alana bağlayabilmesi için burada erken ve açık patlıyoruz.
+ */
+export function baseVersionOf(definition, readTool) {
+    const version = definition.version;
+    if (typeof version === 'string' && version.length > 0)
+        return version;
+    if (typeof version === 'number')
+        return String(version);
+    throw new Error(`Okunan kayıtta 'version' alanı yok; PATCH 'baseVersion' olmadan gönderilemez. ${readTool} çıktısında 'version' görünmüyorsa platform sürümü bu ucu desteklemiyordur.`);
+}

package/dist/platform/refs.js

@@ -0,0 +1,104 @@
+import { PlatformApiError } from './errors.js';
+const guidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function isGuid(value) {
+    return guidPattern.test(value);
+}
+export class RefResolveError extends PlatformApiError {
+}
+/**
+ * Slug → id çözümü çağrı başına yapılır ve çağrılar arasında TAŞINMAZ: gateway stateless, N
+ * replika ile paylaşılan bir önbellek tutarsız olur. Belirsiz slug (aynı ad iki datasource'ta)
+ * sessizce "ilkini al" ile geçilmez — bu planın var oluş nedeni sessiz yanlışı azaltmaktı;
+ * adaylar listelenip `datasource/entity` biçimi istenir.
+ */
+export class RefResolver {
+    platform;
+    project;
+    environment;
+    resolved = [];
+    tree;
+    fieldsByEntity = new Map();
+    constructor(platform, project, environment) {
+        this.platform = platform;
+        this.project = project;
+        this.environment = environment;
+    }
+    async applicationId(ref) {
+        if (isGuid(ref))
+            return ref;
+        const projectPayload = await this.platform.org('GET', `/p/${this.platform.resolveProject(this.project)}`);
+        const applicationsPayload = await this.platform.org('GET', '/applications', { query: { projectId: String(projectPayload.data?.id ?? ''), pageLength: 100 } });
+        const applications = applicationsPayload.data ?? [];
+        const found = applications.find(application => application.slug === ref);
+        if (!found) {
+            throw new RefResolveError(`'${ref}' diye bir application yok. Mevcut slug'lar: ${applications.map(application => application.slug).join(', ') || '(yok)'}`);
+        }
+        this.resolved.push(`applicationId '${ref}' → ${found.id}`);
+        return found.id;
+    }
+    async entity(ref) {
+        const tree = await this.loadTree();
+        const flat = tree
+            .filter((datasource) => Boolean(datasource) && typeof datasource === 'object')
+            .flatMap(datasource => (Array.isArray(datasource.entities) ? datasource.entities : [])
+            .filter((entity) => Boolean(entity) && typeof entity === 'object' && typeof entity.id === 'string')
+            .map(entity => ({ datasource, entity })));
+        if (isGuid(ref)) {
+            const byId = flat.find(({ entity }) => entity.id.toLowerCase() === ref.toLowerCase());
+            if (!byId)
+                throw new RefResolveError(`'${ref}' id'li entity ağaçta yok.`);
+            return { entityId: byId.entity.id, datasourceId: byId.datasource.id, slug: byId.entity.slug };
+        }
+        const separator = ref.indexOf('/');
+        const [datasourcePart, entityPart] = separator === -1 ? [undefined, ref] : [ref.slice(0, separator), ref.slice(separator + 1)];
+        const matches = flat.filter(({ datasource, entity }) => entity.slug === entityPart && (datasourcePart === undefined || datasource.slug === datasourcePart || datasource.name === datasourcePart));
+        if (matches.length === 0) {
+            throw new RefResolveError(`'${ref}' diye bir entity yok. Mevcut slug'lar: ${flat.map(({ entity }) => entity.slug).join(', ') || '(yok)'}`);
+        }
+        if (matches.length > 1) {
+            throw new RefResolveError(`'${ref}' birden çok datasource'ta var: ${matches.map(({ datasource, entity }) => `${datasource.slug}/${entity.slug}`).join(', ')}. 'datasource/entity' biçimiyle verin.`);
+        }
+        const [{ datasource, entity }] = matches;
+        this.resolved.push(`entityId '${ref}' → ${entity.id}`);
+        return { entityId: entity.id, datasourceId: datasource.id, slug: entity.slug };
+    }
+    /**
+     * Entity'nin ham kaydı (alan listesi DIŞINDAKİ kök alanlar için: `localizationEntityId`,
+     * `localizationParentId`, `type`). `entityFields` ile aynı ucu çağırır ve aynı önbelleği
+     * kullanır — iki tur atmaz.
+     */
+    async entityRecord(ref) {
+        const cached = this.recordByEntity.get(ref.entityId);
+        if (cached)
+            return cached;
+        const payload = await this.platform.tenant('GET', this.project, `/entities/${ref.datasourceId}/${ref.entityId}`, { environment: this.environment });
+        const record = payload.data ?? {};
+        this.recordByEntity.set(ref.entityId, record);
+        return record;
+    }
+    async entityFields(ref) {
+        const cached = this.fieldsByEntity.get(ref.entityId);
+        if (cached)
+            return cached;
+        const payload = await this.platform.tenant('GET', this.project, `/entities/${ref.datasourceId}/${ref.entityId}`, { environment: this.environment });
+        const fields = (payload.data?.fields ?? [])
+            .filter(field => typeof field?.id === 'string' && field.id !== '' && typeof field.slug === 'string' && field.slug !== '')
+            .map(field => ({
+            id: String(field.id),
+            slug: String(field.slug),
+            relationType: String(field.relationType ?? 'none'),
+            relationId: field.relationId ?? null,
+            primaryKey: field.primaryKey === true
+        }));
+        this.fieldsByEntity.set(ref.entityId, fields);
+        return fields;
+    }
+    recordByEntity = new Map();
+    async loadTree() {
+        if (this.tree)
+            return this.tree;
+        const payload = await this.platform.tenant('GET', this.project, '/datasources/tree', { environment: this.environment });
+        this.tree = Array.isArray(payload) ? payload : (payload?.data ?? []);
+        return this.tree;
+    }
+}

package/dist/platform/responses.js

@@ -1,5 +1,7 @@
 import { logError, logStep } from '../observability/trace.js';
 import { PlatformApiError } from './errors.js';
+import { PolicyBlockError } from '../knowledge/policy.js';
+import { maskSecrets } from './secrets.js';
 export function prune(value) {
     if (Array.isArray(value))
         return value.map(prune);
@@ -125,13 +127,20 @@ function asStructured(payload) {
         return payload;
     return { data: payload };
 }
-export function toolResult(payload, config) {
+export function toolResult(payload, config, expectFailure) {
     const pruned = prune(payload);
-    const runtimeErrors = runtimeErrorSummary(pruned);
+    const { payload: safe, masked, tokenRefs } = maskSecrets(pruned);
+    const runtimeErrors = runtimeErrorSummary(safe);
     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);
+        // Kasıtlı negatif test (expectFailure:true) bir kusur değil bir KANIT: çağıran beklediğini
+        // söylediyse SONUÇ satırı 'başarılı' yazılır ve ölçüm aracının plansız hata oranını şişirmez
+        // (pages.ts'teki page_screenshot expectFailure deseniyle aynı; artık her handle()'lı tool'da geçerli).
+        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${expectFailure === true ? ' (expectFailure:true — kasıtlı negatif test)' : ''}`, runtimeErrors);
     }
-    const { payload: bounded, truncated } = shrink(pruned, config.maxResponseBytes);
+    if (masked.length > 0) {
+        logStep('maskeleme', `${masked.length} gizli alan yanıttan çıkarıldı — değer *** ile değiştirildi, yolu gatewayMasked'de`, masked);
+    }
+    const { payload: bounded, truncated } = shrink(safe, 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)`);
@@ -139,6 +148,9 @@ export function toolResult(payload, config) {
     const enriched = {
         ...structured,
         ...(runtimeErrors.length > 0 ? { runtimeErrors } : {}),
+        ...(runtimeErrors.length > 0 && expectFailure === true ? { expectedFailure: true } : {}),
+        ...(masked.length > 0 ? { gatewayMasked: masked } : {}),
+        ...(Object.keys(tokenRefs).length > 0 ? { tokenRefs, tokenRefNote: "Maskelenen JWT'ler gateway içinde tutuldu; bu referansları page_screenshot / page_runtime_get 'asUser' alanına verebilirsiniz (15 dk geçerli). Jetonun kendisi yanıta ve günlüğe hiç girmez." } : {}),
         ...(truncated ? { truncated: true, truncationNote: 'Liste, yanıt boyutu sınırı nedeniyle kırpıldı; sayfalama ya da daha dar filtre kullanın.' } : {})
     };
     return {
@@ -148,7 +160,8 @@ export function toolResult(payload, config) {
 }
 export function toolError(error) {
     logError(error);
-    const message = error instanceof PlatformApiError
+    // Politika durdurması bilinçli bir karardır, "beklenmeyen" değil (33/S-5).
+    const message = error instanceof PlatformApiError || error instanceof PolicyBlockError
         ? error.message
         : error instanceof Error
             ? `Beklenmeyen gateway hatası: ${error.message}`
@@ -161,7 +174,13 @@ export function toolError(error) {
 export function handle(config, run) {
     return async (args) => {
         try {
-            return toolResult(await run(args), config);
+            // Tool'un kendi input şeması `expectFailure: z.boolean().optional()` taşıyorsa (ör.
+            // microservice_execute, automation_preview) burada otomatik okunur ve toolResult'a geçirilir
+            // — kasıtlı negatif testler (yanlış parola, yetkisiz erişim, iş kuralı ihlali) ölçüm
+            // aracının plansız hata oranını şişirmez. Şemasında bu alan olmayan tool'larda args'ta
+            // anahtar hiç bulunmaz, davranış değişmez.
+            const expectFailure = args?.expectFailure === true;
+            return toolResult(await run(args), config, expectFailure);
         }
         catch (error) {
             return toolError(error);