@appaflytech/zeyrek-ai-mcp 0.0.4 → 0.0.6

package/dist/tools/entities.js

@@ -1,7 +1,10 @@
-import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { guid, entityRef, resolveEntityId, withResolved, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive, microOps } from './common.js';
+import { RefResolver, isGuid } from '../platform/refs.js';
 import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
 import { splitJunctionFields, withNormalization } from '../knowledge/normalize.js';
-import { entityOutline, resolvePart } from '../knowledge/outlines.js';
+import { unmappedMembers, introducedUnmappedMembers, withUnmappedMembers } from '../knowledge/schemaGuard.js';
+import { entityOutline, resolvePart, resolvePatchOperations, patchedSections } from '../knowledge/outlines.js';
+import { patchResult, baseVersionOf } from '../platform/patch.js';
 import { isJunctionField, policyRules } from '../knowledge/rules.js';
 import { handle } from '../platform/responses.js';
 import fastJsonPatch from 'fast-json-patch';
@@ -20,6 +23,52 @@ function preserveApplicationBinding(definition) {
     if (applicationIds.length > 0)
         definition.applicationIds = applicationIds;
 }
+/**
+ * `UpdateEntityCommandHandler` gövdedeki `Indexes` null ise onu BOŞ LİSTEYE çeviriyor
+ * (`request.Indexes?…ToList() ?? []`) ve `Entity.FindProcessedIndexes` boş listede entity'nin
+ * bütün index'lerini silinecek kümeye koyuyor: kayıt düşer, `DROP INDEX` koşar, hata dönmez.
+ * Domain katmanı null'ı özellikle koruyor, komut katmanı bu korumayı geçersiz kılıyor.
+ *
+ * Gateway alan verilmemişse mevcut index'leri gövdeye taşır. Bilinçli silme yolu kapanmaz:
+ * `indexes: []` AÇIKÇA yazılmışsa buraya hiç girilmez.
+ */
+async function carryIndexes(platform, resolver, project, environment, datasourceId, id, body) {
+    const entity = datasourceId && isGuid(id) ? { entityId: id, datasourceId } : await resolver.entity(id);
+    const current = await platform.tenant('GET', project, `/entities/${entity.datasourceId}/${entity.entityId}`, { environment });
+    const definition = (current?.data ?? current);
+    const indexes = Array.isArray(definition?.indexes) ? definition.indexes : [];
+    if (indexes.length === 0)
+        return [];
+    body.indexes = indexes;
+    return [`Gövdede 'indexes' yoktu: platform bu durumda entity'nin BÜTÜN index'lerini siler, bu yüzden mevcut ${indexes.length} index gövdeye taşındı. Silmek istiyorsanız 'indexes: []' yazarak açıkça isteyin.`];
+}
+/**
+ * `Entity.FindProcessedIndexes` farkı YALNIZ `id` üzerinden alıyor: aynı `id` ile gelen index ne
+ * eklenenler ne silinenler kümesinde olduğu için `EntityService.UpdateAsync` ona hiç dokunmuyor.
+ * Ad, unique bayrağı ya da alan listesi değişse bile ne kayıt ne DDL güncellenir; istek 200 döner
+ * ve yama uygulanmış görünür. Politika kuralı olamaz — kural yalnız yamalanmış gövdeyi görür,
+ * bu karşılaştırma ÖNCEKİ hâli de ister.
+ */
+function inPlaceIndexEdits(before, after) {
+    const asIndexes = (value) => {
+        const source = (value && typeof value === 'object' ? value : {});
+        return Array.isArray(source.indexes)
+            ? source.indexes.filter((index) => Boolean(index) && typeof index === 'object')
+            : [];
+    };
+    const shape = (index) => JSON.stringify([index.name ?? null, index.unique ?? false, Array.isArray(index.fieldIds) ? index.fieldIds : []]);
+    const original = new Map(asIndexes(before)
+        .filter(index => typeof index.id === 'string')
+        .map(index => [index.id, shape(index)]));
+    return asIndexes(after)
+        .filter(index => typeof index.id === 'string' && original.has(index.id) && original.get(index.id) !== shape(index))
+        .map(index => ({
+        ruleId: 'ENT-014',
+        severity: 'warn',
+        message: `'${index.id}' id'li index'in tanımı değişti ama platform var olan bir index'i YERİNDE GÜNCELLEMEZ: farkı yalnız 'id' üzerinden alır, aynı id'yi taşıyan kaydı ne siler ne yeniden kurar. İstek 200 dönse de veritabanında hiçbir şey değişmez. Index'i kaldırıp yeni bir id ile yeniden ekleyin.`,
+        guide: 'ngapps://guides/entity'
+    }));
+}
 export function registerEntityTools(server, platform) {
     const config = platform.config;
     server.registerTool('entity_list', {
@@ -38,39 +87,42 @@ export function registerEntityTools(server, platform) {
     }, handle(config, ({ project, environment, datasourceId, ...query }) => platform.tenant('GET', project, `/entities/${datasourceId}`, { environment, query })));
     server.registerTool('entity_get', {
         title: 'Entity getir',
-        description: "Entity'yi alan tanımlarıyla getirir. Çok alanlı entity'de önce view:'outline' (alan listesi), sonra view:'part' ile tek alan çekin.",
+        description: "Entity'yi alan tanımlarıyla getirir. Çok alanlı entity'de önce view:'outline' (alan listesi), sonra view:'part' ile tek alan çekin. Çok dilli entity'de kök alanlar companion bağını taşır: parent'ta `localizationEntityId`, companion'da `localizationParentId` — companion'ı ad kalıbından TAHMİN ETMEYİN, bu bağdan bulun.",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
-            datasourceId: guid,
-            id: guid,
+            datasourceId: guid.optional().describe('Verilmezse gateway datasource ağacından bulur'),
+            id: entityRef,
             view: z.enum(['full', 'outline', 'part']).optional().describe('varsayılan full'),
             part: z.string().optional().describe("view:'part' için yol, ör. fields[slug=email] veya indexes[0]")
         },
         annotations: readOnly
     }, handle(config, async ({ project, environment, datasourceId, id, view, part }) => {
-        const payload = await platform.tenant('GET', project, `/entities/${datasourceId}/${id}`, { environment });
+        const resolver = new RefResolver(platform, project, environment);
+        const entity = datasourceId && isGuid(id) ? { entityId: id, datasourceId } : await resolver.entity(id);
+        const payload = await platform.tenant('GET', project, `/entities/${entity.datasourceId}/${entity.entityId}`, { environment });
         const definition = (payload?.data ?? payload);
         if (view === 'outline')
-            return entityOutline(definition);
+            return withResolved(entityOutline(definition), resolver.resolved);
         if (view === 'part') {
             if (!part)
                 throw new Error("view:'part' için 'part' parametresi zorunlu.");
-            return { part, value: resolvePart(definition, part) };
+            return withResolved({ part, value: resolvePart(definition, part) }, resolver.resolved);
         }
-        return payload;
+        return withResolved(payload, resolver.resolved);
     }));
     server.registerTool('entity_create', {
         title: 'Entity oluştur',
-        description: "Datasource altında yeni entity oluşturur (definition = CreateEntityCommand: name, fields[], applicationIds, ...). İlişkiler ve alan tipi kararı için platform_guide('entity') okuyun. Gövde politika kontrolünden geçer. applicationIds create'te platformca bağlanır (CreateEntityCommandHandler entityApplications'ı Entity ctor'una geçirir); satır uçları bu bağa İHTİYAÇ DUYMAZ — bağ yalnız Studio'nun application'a göre entity listesini ve bağımlılık sorgularını etkiler.",
+        description: "Datasource altında yeni entity oluşturur (definition = CreateEntityCommand: name, fields[], applicationIds, ...). İlişkiler ve alan tipi kararı için platform_guide('entity') okuyun. Gövde politika kontrolünden geçer. applicationIds create'te platformca bağlanır (CreateEntityCommandHandler entityApplications'ı Entity ctor'una geçirir); satır uçları bu bağa İHTİYAÇ DUYMAZ — bağ yalnız Studio'nun application'a göre entity listesini ve bağımlılık sorgularını etkiler. `fields[].isLocalized: true` alanı ana tablodan çıkarıp companion `<slug>_localization` entity'sine taşır (yalnız düz METİN alanı; anahtar/unique/ilişki olamaz) — platform_guide('entity') §'Çoklu dilli alan'.",
         inputSchema: { project: projectParam, environment: environmentParam, datasourceId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
         annotations: writes
     }, handle(config, async ({ project, environment, datasourceId, definition, policyOverride }) => {
         const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'entity', definition, { operation: 'create' }, policyOverride));
         const { base, deferred } = splitJunctionFields(definition, isJunctionField);
+        const drift = unmappedMembers('CreateEntityCommand', base);
         const payload = await platform.tenant('POST', project, `/entities/${datasourceId}`, { environment, body: base });
         if (deferred.length === 0)
-            return attachFindings(payload, findings);
+            return attachFindings(withUnmappedMembers(payload, drift), findings);
         const created = (payload?.data ?? payload);
         const createdId = String(created?.id ?? '');
         if (!createdId) {
@@ -82,7 +134,7 @@ export function registerEntityTools(server, platform) {
         preserveApplicationBinding(full);
         const updated = await platform.tenant('PUT', project, `/entities/${createdId}`, { environment, body: full });
         const note = `m2m/çoklu alanlar (${deferred.map(field => field.slug ?? field.name).join(', ')}) ayrı bir güncelleme turunda eklendi: create yolu junction kaydını açar ama fiziksel tabloyu kurmaz (platform bug'ı P-01), update yolu kurar.`;
-        return attachFindings(withNormalization(updated, [note]), findings);
+        return attachFindings(withUnmappedMembers(withNormalization(updated, [note]), drift), findings);
     }));
     server.registerTool('entity_create_discovered', {
         title: 'Keşfedilen entity\'leri içe al',
@@ -92,34 +144,67 @@ export function registerEntityTools(server, platform) {
     }, handle(config, ({ project, environment, datasourceId, definition }) => platform.tenant('POST', project, `/entities/${datasourceId}/discovered`, { environment, body: definition })));
     server.registerTool('entity_update', {
         title: 'Entity güncelle',
-        description: 'Entity tanımını günceller (tam gövde). Hedefli değişiklik için entity_patch tercih edin. Gövde politika kontrolünden geçer.',
-        inputSchema: { project: projectParam, environment: environmentParam, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        description: "Entity tanımını günceller (tam gövde). Hedefli değişiklik için entity_patch tercih edin. Gövde politika kontrolünden geçer. DİKKAT: gövdede 'indexes' YOKSA platform entity'nin bütün index'lerini siler — gateway alan verilmemişse mevcut index'leri taşır ve bunu bildirir; silmek için 'indexes: []' yazın. `fields[].isLocalized: true` alanı ana tablodan çıkarıp companion `<slug>_localization` entity'sine taşır (yalnız düz METİN alanı; anahtar/unique/ilişki olamaz) — platform_guide('entity') §'Çoklu dilli alan'.",
+        inputSchema: { project: projectParam, environment: environmentParam, datasourceId: guid.optional().describe('Verilmezse gateway datasource ağacından bulur'), id: entityRef, definition: definitionParam, policyOverride: policyOverrideParam },
         annotations: updates
-    }, handle(config, async ({ project, environment, id, definition, policyOverride }) => {
+    }, handle(config, async ({ project, environment, datasourceId, id, definition, policyOverride }) => {
         const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'entity', definition, { operation: 'update' }, policyOverride));
-        const payload = await platform.tenant('PUT', project, `/entities/${id}`, { environment, body: definition });
-        return attachFindings(payload, findings);
+        const resolver = new RefResolver(platform, project, environment);
+        const body = { ...definition };
+        const notes = Object.hasOwn(body, 'indexes') ? [] : await carryIndexes(platform, resolver, project, environment, datasourceId, id, body);
+        const entityId = await resolveEntityId(resolver, id);
+        const drift = unmappedMembers('UpdateEntityCommand', definition);
+        const payload = await platform.tenant('PUT', project, `/entities/${entityId}`, { environment, body });
+        return attachFindings(withUnmappedMembers(withResolved(withNormalization(payload, notes), resolver.resolved), drift), findings);
     }));
     server.registerTool('entity_patch', {
         title: 'Entity\'ye patch uygula',
-        description: "Tam gövdeyi bağlama almadan hedefli değişiklik: gateway mevcut tanımı çeker, JSON Patch uygular, politika kontrolünden geçirir, geri yazar. Yanıt outline özetidir. GET 'applications' döner ama UpdateEntityCommand 'applicationIds' okur; gateway bu çeviriyi kendisi yapar, yoksa her patch application bağını sessizce siler.",
-        inputSchema: { project: projectParam, environment: environmentParam, datasourceId: guid, id: guid, operations: patchOperationsParam, policyOverride: policyOverrideParam },
+        description: "Tam gövdeyi bağlama almadan hedefli değişiklik: gateway mevcut tanımı okur, yolları çözer ve op'ları platformun PATCH /entities/{id} ucuna `{ baseVersion, ops }` olarak geçirir — tam gövde PUT'u ATILMAZ, yalnız fark yazılır. Yanıt outline özetidir. YOLLARDA SEÇİCİ KULLANIN, indeks değil: '/fields[slug=email]/nullable' — indeksle yazmak alan sırası değişince SESSİZCE yanlış alanı yazar. Gateway seçiciyi indekse çevirir ve hangi kayda indiğini yanıttaki patchTargets ile söyler. `baseVersion` okunan kaydın `version` alanından gelir; kayıt bu arada değiştiyse platform 409 döner ve HİÇBİR op uygulanmaz. 'applications' → 'applicationIds' çevirisini artık platform yapar. `fields[].isLocalized: true` alanı ana tablodan çıkarıp companion `<slug>_localization` entity'sine taşır (yalnız düz METİN alanı; anahtar/unique/ilişki olamaz) — platform_guide('entity') §'Çoklu dilli alan'.",
+        inputSchema: { project: projectParam, environment: environmentParam, datasourceId: guid.optional().describe('Verilmezse gateway datasource ağacından bulur'), id: entityRef, operations: patchOperationsParam.optional(), ops: patchOperationsParam.optional().describe("'operations' ile aynı alan (eşanlamlı) — sayfa micro-op tool'larıyla aynı adı kullanabilmeniz için"), policyOverride: policyOverrideParam },
         annotations: updates
-    }, handle(config, async ({ project, environment, datasourceId, id, operations, policyOverride }) => {
-        const current = await platform.tenant('GET', project, `/entities/${datasourceId}/${id}`, { environment });
+    }, handle(config, async ({ project, environment, datasourceId, id, operations: givenOperations, ops, policyOverride }) => {
+        const operations = microOps('entity_patch', ops, givenOperations);
+        const resolver = new RefResolver(platform, project, environment);
+        const entity = datasourceId && isGuid(id) ? { entityId: id, datasourceId } : await resolver.entity(id);
+        const current = await platform.tenant('GET', project, `/entities/${entity.datasourceId}/${entity.entityId}`, { environment });
         const definition = structuredClone((current?.data ?? current));
-        const patched = fastJsonPatch.applyPatch(definition, operations, true, false).newDocument;
-        preserveApplicationBinding(patched);
-        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'entity', patched, { operation: 'update' }, policyOverride));
-        await platform.tenant('PUT', project, `/entities/${id}`, { environment, body: patched });
-        return attachFindings({ applied: operations.length, outline: entityOutline(patched) }, findings);
+        const resolvedOps = resolvePatchOperations(definition, operations, 'entity_get');
+        // Politika, yazmadan önce sonucu görmeli; yerel kopya YALNIZ değerlendirme için, gövde olarak gönderilmez.
+        const preview = fastJsonPatch.applyPatch(definition, resolvedOps.operations, true, false).newDocument;
+        const findings = [
+            ...enforcePolicy(evaluatePolicy(config, policyRules, 'entity', preview, { operation: 'update' }, policyOverride)),
+            ...inPlaceIndexEdits(current?.data ?? current, preview)
+        ];
+        // Yalnız YAMANIN eklediği anahtar bildirilir: gövdenin geri kalanını gateway GET'ten taşıdı
+        // ve orada komutta olmayan yedi yapısal alan var (ölçüldü — g-03 Adım 0). Onları bildirmek
+        // kanalı gürültüye boğar ve gerçek sinyali gömer.
+        const drift = introducedUnmappedMembers('UpdateEntityCommand', (current?.data ?? current), preview);
+        const saved = await platform.tenant('PATCH', project, `/entities/${entity.entityId}`, {
+            environment,
+            body: { baseVersion: baseVersionOf(definition, 'entity_get'), ops: resolvedOps.operations }
+        });
+        const written = patchResult(saved, preview);
+        const touched = patchedSections(written.data, resolvedOps.operations);
+        return attachFindings(withUnmappedMembers(withResolved({
+            applied: operations.length,
+            newVersion: written.newVersion,
+            patchTargets: resolvedOps.targets,
+            ...(resolvedOps.notes.length > 0 ? { resolvedPaths: resolvedOps.notes } : {}),
+            // S-8: yazılanın kanıtı yanıtta dursun; dokunulmayan bölümler outline'da kalır.
+            ...(Object.keys(touched).length > 0 ? { touched } : {}),
+            outline: entityOutline(written.data)
+        }, resolver.resolved), drift), findings);
     }));
     server.registerTool('entity_delete', {
         title: 'Entity sil',
         description: 'Entity tanımını siler; önce entity_dependencies ile bağımlılıklarını kontrol edin.',
-        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        inputSchema: { project: projectParam, environment: environmentParam, id: entityRef },
         annotations: destructive
-    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/entities/${id}`, { environment })));
+    }, handle(config, async ({ project, environment, id }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const entityId = await resolveEntityId(resolver, id);
+        return withResolved(await platform.tenant('DELETE', project, `/entities/${entityId}`, { environment }), resolver.resolved);
+    }));
     server.registerTool('entity_clone', {
         title: 'Entity klonla',
         description: 'Entity\'nin kopyasını oluşturur.',

package/dist/tools/externalComponents.js

@@ -4,8 +4,11 @@ import { PlatformApiError } from '../platform/errors.js';
 import { handle } from '../platform/responses.js';
 import { basename, join, resolve } from 'node:path';
 import { z } from 'zod';
-/** Platformun köprü protokolü; scaffold ve publish bu sürüme göre üretir/doğrular */
-const PROTOCOL_VERSION = 1;
+import { evaluatePolicy, enforcePolicy } from '../knowledge/policy.js';
+import { policyRules } from '../knowledge/rules.js';
+import { EXTERNAL_COMPONENT_PROTOCOL_VERSION } from '../knowledge/backendConstraints.js';
+/** Platformun köprü protokolü; scaffold ve publish bu sürüme göre üretir/doğrular (backend ExternalComponentRules.CurrentProtocolVersion) */
+const PROTOCOL_VERSION = EXTERNAL_COMPONENT_PROTOCOL_VERSION;
 /** Backend `ExternalComponentRules.MaxBundleSizeBytes` ile aynı sınır */
 const maxBundleBytes = 2 * 1024 * 1024;
 const slugPattern = /^x-[a-z][a-z0-9-]*$/;
@@ -185,7 +188,7 @@ export function registerExternalComponentTools(server, platform) {
     }));
     server.registerTool('external_component_publish', {
         title: 'Harici komponenti yayınla',
-        description: "Komponent kaydını ve paketini platforma yükler. Paket sunucudaki doğrulama hattından geçer (şema + güvenlik taraması); block bulgusu varsa depolamaya hiç yazılmaz ve rapor döner. Kabul edilen paket taslak (draft) olarak kaydedilir — Studio önizlemesinde görünür, yayınlanmış uygulamada görünmez; yayına almak için external_component_activate. Dosyalar gateway sürecinin okuyabildiği yerel yollardır, içerikleri model bağlamına girmez.",
+        description: "Komponent kaydını ve paketini platforma yükler. Paket sunucudaki doğrulama hattından geçer (şema + güvenlik taraması); block bulgusu varsa depolamaya hiç yazılmaz ve rapor döner. Kabul edilen paket taslak (draft) olarak kaydedilir — Studio önizlemesinde görünür, yayınlanmış uygulamada görünmez; yayına almak için external_component_activate. Dosyalar gateway sürecinin okuyabildiği yerel yollardır, içerikleri model bağlamına girmez. Backend ön kontrolü (EXT-001, block): protocolVersion 1, definition.blocks dolu, props[].name ayrılmış DOM adı ya da zx/on önekli olamaz, props[].type sözlükten (ngapps://rules/backend-constraints).",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
@@ -219,6 +222,9 @@ export function registerExternalComponentTools(server, platform) {
         if (bytes.byteLength > maxBundleBytes) {
             throw new PlatformApiError(`external_component_publish: paket ${maxBundleBytes} bayt sınırını aşıyor (${bytes.byteLength} B).`);
         }
+        // EXT-001: protocolVersion, definition.blocks, ayrılmış prop adları ve prop tipleri — kayıt
+        // ucu 422 dönmeden manifest'te yakalanır; paket yükleme ikinci istek olduğu için yarım kayıt kalmaz.
+        enforcePolicy(evaluatePolicy(config, policyRules, 'externalComponent', { ...manifest, slug }, { operation: 'create' }));
         const record = await platform.tenant('POST', project, `/components/${applicationId}/external`, {
             environment,
             body: {

package/dist/tools/files.js

@@ -4,9 +4,12 @@ import { handle } from '../platform/responses.js';
 import { readFile, writeFile } from 'node:fs/promises';
 import { basename, extname, resolve } from 'node:path';
 import { z } from 'zod';
+import { FORBIDDEN_NAME_CHARACTERS } from '../knowledge/backendConstraints.js';
 const maxInlineBytes = 8 * 1024 * 1024;
 const maxUploadBytes = 50 * 1024 * 1024;
-const forbiddenNameChars = `\\|!#~$%&/=?»«@£§€{};'<>,`;
+/** Metin içerik bağlamdan geçtiği için base64'ün 8 MB sınırından çok daha dar tutulur (G-26). */
+const maxTextBytes = 1024 * 1024;
+const forbiddenNameChars = FORBIDDEN_NAME_CHARACTERS;
 const mimeTypes = {
     '.css': 'text/css',
     '.csv': 'text/csv',
@@ -51,20 +54,22 @@ export function registerFileTools(server, platform) {
     }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/files/${id}`, { environment })));
     server.registerTool('file_upload', {
         title: 'Dosya yükle',
-        description: "Dosyayı projenin depolamasına yükler ve FileDto (id + serve adresleri) döner. İçerik iki yoldan verilir: `path` — gateway sürecinin okuyabildiği yerel yol (büyük dosyalar için tercih edilir, içerik model bağlamına girmez), ya da `content` — base64 (8 MB'a kadar) + `filename`. Platform sınırı 50 MB; dosya adı \\|!#~$%&/=?»«@£§€{};'<>, karakterlerini içeremez. Yüklenen dosya sayfada `image`/`file-viewer` komponentiyle gösterilir ya da satır alanına yol olarak yazılır.",
+        description: "Dosyayı projenin depolamasına yükler ve FileDto (id + serve adresleri) döner. İçerik ÜÇ yoldan verilir: `text` — düz metin içerik (SVG, CSV, Markdown, JSON…) + `filename`; base64'e çevirmeye gerek yok, bunu gateway yapar. `path` — gateway sürecinin okuyabildiği yerel yol (büyük ve ikili dosyalar için). `content` — base64 (8 MB'a kadar) + `filename`. Platform sınırı 50 MB; dosya adı \\|!#~$%&/=?»«@£§€{};'<>, karakterlerini içeremez. Yüklenen dosya sayfada `image`/`file-viewer` komponentiyle gösterilir ya da satır alanına yol olarak yazılır.",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
             path: z.string().min(1).optional().describe("Gateway sürecinin okuyabildiği yerel dosya yolu; `content` ile birlikte verilmez"),
             content: z.string().min(1).optional().describe('Base64 kodlanmış dosya içeriği; `filename` ile birlikte zorunludur'),
+            text: z.string().min(1).optional().describe("Düz metin içerik (UTF-8): SVG, CSV, Markdown, JSON, düz metin. `filename` ile birlikte zorunludur ve base64'e çevirmeye gerek yoktur — yalnız MCP araçlarıyla çalışan bir ajanın elinde base64 kodlayıcı yok, bu alan o boşluğu kapatır (G-26). İkili dosyalar için `path` ya da `content` kullanın."),
             filename: z.string().min(1).optional().describe("`content` ile zorunlu; `path` verildiğinde dosya adını ezer"),
             contentType: z.string().min(1).optional().describe('Belirtilmezse uzantıdan çözülür, bilinmeyen uzantıda application/octet-stream'),
             folderId: guid.optional().describe('Hedef klasör (folder_list); boşsa kök')
         },
         annotations: writes
-    }, handle(config, async ({ project, environment, path, content, filename, contentType, folderId }) => {
-        if (!path === !content) {
-            throw new PlatformApiError("file_upload: `path` ya da `content` parametrelerinden tam olarak biri verilmeli — `path` gateway'in okuyabildiği yerel dosya, `content` base64 içerik (`filename` ile).");
+    }, handle(config, async ({ project, environment, path, content, text, filename, contentType, folderId }) => {
+        const given = [path, content, text].filter(value => value !== undefined);
+        if (given.length !== 1) {
+            throw new PlatformApiError("file_upload: `path`, `content` ya da `text` parametrelerinden tam olarak biri verilmeli — `path` gateway'in okuyabildiği yerel dosya, `content` base64 içerik, `text` düz metin (ikisi de `filename` ile).");
         }
         let bytes;
         let name;
@@ -78,6 +83,15 @@ export function registerFileTools(server, platform) {
             }
             name = filename ?? basename(absolute);
         }
+        else if (text !== undefined) {
+            if (!filename)
+                throw new PlatformApiError('file_upload: `text` verildiğinde `filename` zorunludur.');
+            bytes = Buffer.from(text, 'utf8');
+            if (bytes.byteLength > maxTextBytes) {
+                throw new PlatformApiError(`file_upload: \`text\` içeriği ${maxTextBytes} bayt sınırını aşıyor (${bytes.byteLength} B). Büyük dosyalar için \`path\` ya da \`content\` kullanın.`);
+            }
+            name = filename;
+        }
         else {
             if (!filename)
                 throw new PlatformApiError('file_upload: `content` verildiğinde `filename` zorunludur.');
@@ -94,7 +108,7 @@ export function registerFileTools(server, platform) {
         }
         const offendingChar = [...forbiddenNameChars].find(character => name.includes(character));
         if (offendingChar) {
-            throw new PlatformApiError(`file_upload: dosya adı '${offendingChar}' karakterini içeriyor; platform doğrulaması bunu reddeder. Yasak karakterler: ${forbiddenNameChars}`);
+            throw new PlatformApiError(`file_upload: dosya adı '${offendingChar}' karakterini içeriyor; platform doğrulaması bunu 422 ile reddeder (FILE-001, UploadFileCommandValidator). Yasak karakterler: ${forbiddenNameChars}`);
         }
         const resolvedType = contentType ?? mimeTypes[extname(name).toLowerCase()] ?? 'application/octet-stream';
         const multipart = folderId

package/dist/tools/flows.js

@@ -1,15 +1,36 @@
 import { fetchHost, flowPath, hostParam, hostUpdateBody, unwrap } from './screens.js';
-import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive } from './common.js';
+import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive, microOps } from './common.js';
 import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
-import { normalizeFlowSteps, withNormalization } from '../knowledge/normalize.js';
+import { normalizeFlowSteps, unknownSetterTargetWarnings, withNormalization } from '../knowledge/normalize.js';
 import { flowBodyWarnings } from '../knowledge/coverage.js';
 import { PlatformApiError } from '../platform/errors.js';
 import { handle } from '../platform/responses.js';
+import { writeDiff, withWriteDiff } from '../platform/writeDiff.js';
+import { resolvePatchOperations } from '../knowledge/outlines.js';
+import { patchResult, baseVersionOf } from '../platform/patch.js';
+import fastJsonPatch from 'fast-json-patch';
 import { policyRules } from '../knowledge/rules.js';
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
+/**
+ * Akış yazması yanıtında gövdeyi geri döndürmüyor, bu yüzden diff için akışı bir kez okuruz.
+ * ÖLÇÜLDÜ 2026-09-05 (Corecruiter koşusu, `S-19`): `code` adımının gövdesi kaydedilmedi,
+ * `flow_create` 200 döndü, `flow_get` adımı gösterdi ama `args` içinde kodu taşıyan alan yoktu —
+ * teşhis ~10 dakika sürdü ve tek belirti filtrenin hiçbir şey yapmamasıydı. Okuma başarısız
+ * olursa yazma yine başarılıdır: diff bir teşhis eklentisidir, yazmanın sonucu değil.
+ */
+async function flowWriteDrops(platform, host, project, environment, applicationId, hostId, flowId, sent) {
+    try {
+        const saved = unwrap(await platform.tenant('GET', project, flowPath(host, applicationId, hostId, flowId), { environment }));
+        return writeDiff(sent, saved);
+    }
+    catch {
+        return { dropped: [], normalized: [] };
+    }
+}
 const stepsParam = z.array(z.record(z.unknown())).describe("Adım listesi (StepManagementSchema: { stepId, name, type, kind, args, branches }). DİKKAT: branches[].nextStepId bir GUID değil, hedef adımın stepId STRING'idir; dal ADI motorun anahtarıdır ve start/setter/code adımlarında 'always' olmak zorundadır. Tam şablon: ngapps://examples/flow-load-table (ya da flow_get çıktısı); adım tipleri ve setter/parameters şekli platform_guide('page') Kural 1c.");
 const policyOverrideParam = z.boolean().optional();
+const patchOperationsParam = z.array(z.record(z.unknown())).min(1).describe("RFC 6902 JSON Patch işlemleri; yolları flow_get çıktısıyla keşfedin. Dizi öğelerinde indeks yerine seçici kullanılabilir: '/steps[stepId=paint]/args/iteratees[element=tbl_recruiters]/mapping/source' — seçici gövde platforma gitmeden indekse çevrilir, çözülemezse istek hiç gönderilmez.");
 const flowIdParam = guid.describe("Akış id'si; şemadaki events[].value bu id'dir");
 function flowSummary(flow) {
     return {
@@ -22,7 +43,15 @@ function flowSummary(flow) {
 }
 async function hostEnvelope(platform, host, project, environment, applicationId, hostId) {
     const record = await fetchHost(platform, host, project, environment, applicationId, hostId);
-    return { [host]: hostUpdateBody(host, { ...record, applicationId }) };
+    return { record, envelope: { [host]: hostUpdateBody(host, { ...record, applicationId }) } };
+}
+/**
+ * FLOW-024'ün arayacağı düğüm kümesi. Ham kaydın TAMAMI gezilmez: kayıt kendi `flows`'unu da
+ * taşıyabilir ve oradaki bayat element id'leri kümeyi kirletip aramayı sessizce boşa çıkarır.
+ * page/component düğümleri `schema`'da, layout'unkiler `views`'ta durur.
+ */
+function hostNodes(record) {
+    return record.schema ?? record.views ?? [];
 }
 async function requiredParameterWarnings(platform, project, environment, applicationId, steps) {
     const warnings = [];
@@ -146,7 +175,7 @@ export function registerFlowTools(server, platform) {
         },
         annotations: writes
     }, handle(config, async ({ project, environment, host, applicationId, hostId, name, slug, steps, errorSteps, flowId, policyOverride }) => {
-        const envelope = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
+        const { record: hostRecord, envelope } = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
         const resolvedFlowId = flowId ?? randomUUID();
         const flow = {
             id: resolvedFlowId,
@@ -160,16 +189,20 @@ export function registerFlowTools(server, platform) {
         const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'flow', flow, { operation: 'create' }, policyOverride));
         const parameterWarnings = [
             ...await requiredParameterWarnings(platform, project, environment, applicationId, steps),
-            ...flowBodyWarnings(steps)
+            ...flowBodyWarnings(steps),
+            ...unknownSetterTargetWarnings(steps, errorSteps ?? [], hostNodes(hostRecord))
         ];
         await platform.tenant('POST', project, flowPath(host, applicationId, hostId), { environment, body: { flow, ...envelope } });
-        return attachFindings(withNormalization({
+        // Diff YALNIZ çağıranın yazdığı alanları kapsar; `id` ve barındırıcı bağı (`pageId` vb.)
+        // gövdeye gateway koyar, kullanıcının düzeltebileceği bir şey değildir.
+        const drops = await flowWriteDrops(platform, host, project, environment, applicationId, hostId, resolvedFlowId, { name: flow.name, slug: flow.slug, steps: flow.steps, errorSteps: flow.errorSteps });
+        return attachFindings(withWriteDiff(withNormalization({
             host,
             hostId,
             flow: { id: resolvedFlowId, name, slug, steps: steps.length },
             ...(parameterWarnings.length > 0 ? { parameterWarnings } : {}),
             hint: "Akışı bir olaya bağlamak için: page_schema_patch ops:[{op:'set_event', target:<elementId>, event:'<component_get events listesindeki ad>', eventValue:<flow id>}]. Olay adları komponente özeldir ve 'on' ÖNEKİ ALMAZ (button → 'click', form → 'submit', table → 'mount'/'select'/'sort'…); uydurma ad 200 döner ama bağ sessizce ölü kalır — gateway PAGE-008 ile yakalar."
-        }, normalized), findings);
+        }, normalized), drops), findings);
     }));
     server.registerTool('flow_update', {
         title: 'Akış güncelle',
@@ -192,7 +225,7 @@ export function registerFlowTools(server, platform) {
         const current = unwrap(await platform.tenant('GET', project, flowPath(host, applicationId, hostId, flowId), { environment }));
         if (!current.id)
             throw new PlatformApiError(`'${flowId}' id'li akış bulunamadı; flow_list ile doğrulayın.`);
-        const envelope = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
+        const { record: hostRecord, envelope } = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
         const flow = {
             id: flowId,
             name: name ?? current.name,
@@ -208,10 +241,76 @@ export function registerFlowTools(server, platform) {
             : [];
         const parameterWarnings = [
             ...await requiredParameterWarnings(platform, project, environment, applicationId, flow.steps),
-            ...flowBodyWarnings(flow.steps)
+            ...flowBodyWarnings(flow.steps),
+            ...unknownSetterTargetWarnings(flow.steps, flow.errorSteps, hostNodes(hostRecord))
         ];
         await platform.tenant('PUT', project, flowPath(host, applicationId, hostId, flowId), { environment, body: { flow, ...envelope } });
-        return attachFindings(withNormalization({ host, hostId, flow: flowSummary(flow), ...(parameterWarnings.length > 0 ? { parameterWarnings } : {}) }, normalized), findings);
+        // Kısmi güncellemede yalnız GÖNDERİLEN alanlar karşılaştırılır; verilmeyen alan için
+        // "düştü" demek yanlış alarm olurdu.
+        const drops = await flowWriteDrops(platform, host, project, environment, applicationId, hostId, flowId, {
+            ...(name === undefined ? {} : { name }),
+            ...(slug === undefined ? {} : { slug }),
+            ...(steps === undefined ? {} : { steps }),
+            ...(errorSteps === undefined ? {} : { errorSteps })
+        });
+        return attachFindings(withWriteDiff(withNormalization({ host, hostId, flow: flowSummary(flow), ...(parameterWarnings.length > 0 ? { parameterWarnings } : {}) }, normalized), drops), findings);
+    }));
+    server.registerTool('flow_patch', {
+        title: "Akışa patch uygula",
+        description: "Tam gövdeyi bağlama almadan hedefli değişiklik: gateway akışı çeker, JSON Patch uygular, politika kontrolünden geçirip geri yazar. flow_update REPLACE olduğu için tek bir ifadeyi düzeltmek 10 adımlı gövdenin tamamını yeniden göndermek demekti (09-05 koşusunda aynı 11 KB'lik gövde beş kez gönderildi). Dizi öğelerinde indeks yerine SEÇİCİ kullanın — adım ve iteratee sırası platformda değişebilir: '/steps[stepId=paint]/args/iteratees[element=tbl_funnel]/mapping/mappings/share/ref' ya da '/steps[stepId=load_summary]/args/parameters[name=company]/value/ref'. Seçici çözülemezse istek HİÇ gönderilmez.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            host: hostParam,
+            applicationId: guid,
+            hostId: guid,
+            flowId: flowIdParam,
+            operations: patchOperationsParam.optional(),
+            ops: patchOperationsParam.optional().describe("'operations' ile aynı alan (eşanlamlı) — sayfa micro-op tool'larıyla aynı adı kullanabilmeniz için"),
+            policyOverride: policyOverrideParam
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, host, applicationId, hostId, flowId, operations: givenOperations, ops, policyOverride }) => {
+        const operations = microOps('flow_patch', ops, givenOperations);
+        const current = unwrap(await platform.tenant('GET', project, flowPath(host, applicationId, hostId, flowId), { environment }));
+        if (!current.id)
+            throw new PlatformApiError(`'${flowId}' id'li akış bulunamadı; flow_list ile doğrulayın.`);
+        const document = structuredClone(current);
+        const resolved = resolvePatchOperations(document, operations, 'flow_get');
+        const patched = fastJsonPatch.applyPatch(document, resolved.operations, true, false).newDocument;
+        const { record: hostRecord } = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
+        const flow = {
+            ...patched,
+            id: flowId,
+            steps: patched.steps ?? [],
+            errorSteps: patched.errorSteps ?? [],
+            ...(host === 'page' ? { pageId: hostId } : host === 'layout' ? { layoutId: hostId } : { componentId: hostId })
+        };
+        const normalized = [...normalizeFlowSteps(flow.steps), ...normalizeFlowSteps(flow.errorSteps)];
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'flow', flow, { operation: 'update' }, policyOverride));
+        const parameterWarnings = [
+            ...await requiredParameterWarnings(platform, project, environment, applicationId, flow.steps),
+            ...flowBodyWarnings(flow.steps),
+            ...unknownSetterTargetWarnings(flow.steps, flow.errorSteps, hostNodes(hostRecord))
+        ];
+        // Gövde değil FARK gönderilir: barındırıcı zarfı (envelope) yazma yolunda gerekmez, platform
+        // PATCH ucu akışı tek başına yazar. Net diff okunan kayıt ile son hâl arasından hesaplanır.
+        const netOps = fastJsonPatch.compare(current, flow);
+        const saved = await platform.tenant('PATCH', project, flowPath(host, applicationId, hostId, flowId), {
+            environment,
+            body: { baseVersion: baseVersionOf(current, 'flow_get'), ops: netOps }
+        });
+        const written = patchResult(saved, flow);
+        const drops = await flowWriteDrops(platform, host, project, environment, applicationId, hostId, flowId, { steps: flow.steps, errorSteps: flow.errorSteps });
+        return attachFindings(withWriteDiff(withNormalization({
+            host,
+            hostId,
+            applied: operations.length,
+            newVersion: written.newVersion,
+            patchTargets: resolved.targets,
+            flow: flowSummary(written.data),
+            ...(parameterWarnings.length > 0 ? { parameterWarnings } : {})
+        }, [...normalized, ...resolved.notes.map(note => `patch yolu seçiciden indekse çözüldü: ${note}`)]), drops), findings);
     }));
     server.registerTool('flow_delete', {
         title: 'Akış sil',
@@ -219,7 +318,7 @@ export function registerFlowTools(server, platform) {
         inputSchema: { project: projectParam, environment: environmentParam, host: hostParam, applicationId: guid, hostId: guid, flowId: flowIdParam },
         annotations: destructive
     }, handle(config, async ({ project, environment, host, applicationId, hostId, flowId }) => {
-        const envelope = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
+        const { envelope } = await hostEnvelope(platform, host, project, environment, applicationId, hostId);
         await platform.tenant('DELETE', project, flowPath(host, applicationId, hostId, flowId), { environment, body: { id: flowId, ...envelope } });
         return { deleted: flowId, host, hostId };
     }));

package/dist/tools/folders.js

@@ -1,6 +1,8 @@
 import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
 import { handle } from '../platform/responses.js';
 import { z } from 'zod';
+import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
+import { policyRules } from '../knowledge/rules.js';
 export function registerFolderTools(server, platform) {
     const config = platform.config;
     server.registerTool('folder_list', {
@@ -17,10 +19,13 @@ export function registerFolderTools(server, platform) {
     }, handle(config, ({ project, environment, id, breadcrumb }) => platform.tenant('GET', project, breadcrumb ? `/folders/${id}/breadcrumb` : `/folders/${id}`, { environment })));
     server.registerTool('folder_create', {
         title: 'Klasör oluştur',
-        description: "Yeni klasör oluşturur (definition = CreateFolderCommand: { name, parentId? }). DİKKAT: fiziksel klasör adı ve depolama yolu ASCII'ye katlanır ('Donanım' → 'Donanim') ve aynı üst klasörde çakışırsa sonuna ' (1)' eklenir — kullanıcıya gösterilen displayName ham adı korur. Yanıttaki name/path katlanmış hâldir, dosya yollarını oradan okuyun.",
+        description: "Yeni klasör oluşturur (definition = CreateFolderCommand: { name, parentId? }). DİKKAT: fiziksel klasör adı ve depolama yolu ASCII'ye katlanır ('Donanım' → 'Donanim') ve aynı üst klasörde çakışırsa sonuna ' (1)' eklenir — kullanıcıya gösterilen displayName ham adı korur. Yanıttaki name/path katlanmış hâldir, dosya yollarını oradan okuyun. Backend ön kontrolü (FLD-001, block): name zorunlu ve \\|!#~$%&/=?»«@£§€{};'<>, karakterlerini içeremez.",
         inputSchema: { project: projectParam, environment: environmentParam, definition: definitionParam },
         annotations: writes
-    }, handle(config, ({ project, environment, definition }) => platform.tenant('POST', project, '/folders', { environment, body: definition })));
+    }, handle(config, async ({ project, environment, definition }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'folder', definition, { operation: 'create' }));
+        return attachFindings(await platform.tenant('POST', project, '/folders', { environment, body: definition }), findings);
+    }));
     server.registerTool('folder_update', {
         title: 'Klasör yetkilerini güncelle',
         description: "Klasörün YETKİLENDİRMESİNİ günceller — `UpdateFolderCommand`'ın alanları yalnız `middlewareIds` ve `roleIds`'tir. Ad değiştirmek için folder_rename kullanın; **klasör TAŞIMA (parentId değiştirme) platformda desteklenmiyor** — gövdeye parentId/name koyarsanız sessizce yok sayılır ve istek yine 200 döner (etkinlik turu Ç3).",

package/dist/tools/globalFunctions.js

@@ -0,0 +1,63 @@
+import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const identifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const nameParam = z.string().min(1).regex(identifier, 'Geçerli bir JavaScript tanımlayıcısı olmalı')
+    .describe("Motorun bağlayacağı ad; ifadelerde bu adla çağrılır (sum(1, 2)). Sistem fonksiyonlarının adları (Now, UtcNow, GenerateGuid, crypto…) rezervedir ve reddedilir");
+const functionParam = z.string().min(1)
+    .describe("Klasik ya da arrow JavaScript FONKSİYON İFADESİ: '(left, right) => left + right' ya da 'function (a) { return a * 2 }'. Deyim değil ifade olmalı — 'return a + b' gibi bir gövde tek başına reddedilir. Platform kaydetmeden önce gerçek bir Jint motorunda çalıştırıp sonucun çağrılabilir olduğunu doğrular; SÖZDİZİMİ ve çağrılabilirlik denetlenir, gövdenin içindeki serbest değişkenler DENETLENMEZ");
+const descriptionParam = z.string().min(1)
+    .describe('Fonksiyonun ne işe yaradığı; Studio kod editöründe autocomplete infobox başlığı olarak görünür. Zorunludur');
+const schemaParam = z.array(z.object({
+    name: z.string().min(1).regex(identifier, 'Geçerli bir JavaScript tanımlayıcısı olmalı')
+        .describe('Parametre adı; fonksiyon içinde benzersiz olmalı'),
+    description: z.string().min(1).describe('Parametrenin ne olduğu; infobox\'ta parametre satırı olarak görünür. Zorunludur')
+})).describe('Parametre şeması, SIRALI. Yalnız dokümantasyon ve autocomplete imzası için kullanılır — motor çağrıyı bu şemaya göre DOĞRULAMAZ, eksik argüman undefined gelir. Parametresiz fonksiyonda boş dizi verin');
+export function registerGlobalFunctionTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('global_function_list', {
+        title: 'Global fonksiyonları listele',
+        description: "Tenant kapsamındaki global JavaScript fonksiyonlarını listeler. Bunlar her workflow/automation/middleware koşumunda ve Studio preview'ında motora bağlanır; ifadelerde çıplak adla çağrılırlar.",
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/global-functions', { environment })));
+    server.registerTool('global_function_get', {
+        title: 'Global fonksiyonu getir',
+        description: 'Tek bir global fonksiyonun adını, gövdesini, açıklamasını ve parametre şemasını getirir.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/global-functions/${id}`, { environment })));
+    server.registerTool('global_function_create', {
+        title: 'Global fonksiyon tanımla',
+        description: "Yeni global fonksiyon kaydeder. Ad tenant içinde BENZERSİZDİR. Fonksiyon açıklaması ve HER parametre açıklaması zorunludur — Studio bunları autocomplete infobox'ında gösterir. Gövde bağlamdan bağımsız olmalı: içinde 'input' ya da bir adım adı gibi SERBEST DEĞİŞKEN kullanırsanız kayıt geçer ama fonksiyon o değişkenin tanımlı olmadığı her akışta 'X is not defined' ile patlar; dinamik veriyi parametre olarak geçirin.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            name: nameParam,
+            function: functionParam,
+            description: descriptionParam,
+            schema: schemaParam
+        },
+        annotations: writes
+    }, handle(config, ({ project, environment, name, function: body, description, schema }) => platform.tenant('POST', project, '/global-functions', { environment, body: { name, function: body, description, schema } })));
+    server.registerTool('global_function_update', {
+        title: 'Global fonksiyonu güncelle',
+        description: "Global fonksiyonun tamamını değiştirir (PUT — dört alanı da gönderin). ADI DEĞİŞTİRMEK, fonksiyonu çağıran bir workflow varsa 400 ile reddedilir (CantRenameUsedGlobalFunctionException); gövde/açıklama/şema değişikliği serbesttir. Adı gerçekten değiştirmeniz gerekiyorsa önce çağıran akışlardaki ifadeleri güncelleyin.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            name: nameParam,
+            function: functionParam,
+            description: descriptionParam,
+            schema: schemaParam
+        },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, name, function: body, description, schema }) => platform.tenant('PUT', project, `/global-functions/${id}`, { environment, body: { name, function: body, description, schema } })));
+    server.registerTool('global_function_delete', {
+        title: 'Global fonksiyonu sil',
+        description: "Global fonksiyonu siler. Fonksiyonu çağıran bir workflow varsa 400 ile reddedilir (CantDeleteUsedGlobalFunctionException) ve mesaj çağıran akışların adlarını sayar. Eşleşme tam tanımlayıcı sınırıyla aranır: 'checksum' ya da 'mySum' içeren bir ifade 'sum' çağrısı sayılmaz.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/global-functions/${id}`, { environment })));
+}