@appaflytech/zeyrek-ai-mcp 0.0.4 → 0.0.6

package/dist/tools/automations.js

@@ -1,9 +1,12 @@
-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, languageParam } from './common.js';
+import { RefResolver } from '../platform/refs.js';
 import { normalizeWorkflowDefinition, withNormalization } from '../knowledge/normalize.js';
 import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
 import { policyRules } from '../knowledge/rules.js';
+import { languageHeader } from '../knowledge/languageCodes.js';
 import { handle } from '../platform/responses.js';
 import { z } from 'zod';
+import { constraintSummary } from '../knowledge/backendConstraints.js';
 const policyOverrideParam = z.boolean().optional()
     .describe('true: politika block bulgularını warn\'a indirir (bilinçli istisna; yanıtta işaretlenir)');
 export function registerAutomationTools(server, platform) {
@@ -11,93 +14,123 @@ export function registerAutomationTools(server, platform) {
     server.registerTool('automation_list', {
         title: 'Automation listele',
         description: 'Entity\'ye bağlı automation\'ları listeler.',
-        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, searchTerm: z.string().optional(), ...pagingParams },
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: entityRef, searchTerm: z.string().optional(), ...pagingParams },
         annotations: readOnly
-    }, handle(config, ({ project, environment, entityId, ...query }) => platform.tenant('GET', project, `/entities/${entityId}/automation/list`, { environment, query })));
+    }, handle(config, async ({ project, environment, entityId, ...query }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedEntityId = await resolveEntityId(resolver, entityId);
+        return withResolved(await platform.tenant('GET', project, `/entities/${resolvedEntityId}/automation/list`, { environment, query }), resolver.resolved);
+    }));
     server.registerTool('automation_get', {
         title: 'Automation getir',
         description: 'Tek automation\'ı step ağacıyla getirir.',
-        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, id: guid },
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: entityRef, id: guid },
         annotations: readOnly
-    }, handle(config, ({ project, environment, entityId, id }) => platform.tenant('GET', project, `/entities/${entityId}/automation/${id}`, { environment })));
+    }, handle(config, async ({ project, environment, entityId, id }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedEntityId = await resolveEntityId(resolver, entityId);
+        return withResolved(await platform.tenant('GET', project, `/entities/${resolvedEntityId}/automation/${id}`, { environment }), resolver.resolved);
+    }));
     server.registerTool('automation_create', {
         title: 'Automation oluştur',
-        description: "Entity'ye automation bağlar. definition = CreateWorkflowCommand gövdesi ('automation' nesnesi içermeli; entityId route'tan set edilir). İlk kullanımdan önce platform_guide('workflow') okuyun; gövde politika kontrolünden geçer.",
-        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        description: "Entity'ye automation bağlar. definition = CreateWorkflowCommand gövdesi ('automation' nesnesi içermeli; entityId route'tan set edilir). İlk kullanımdan önce platform_guide('workflow') okuyun; gövde politika kontrolünden geçer. " + constraintSummary('CreateWorkflowCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: entityRef, definition: definitionParam, policyOverride: policyOverrideParam },
         annotations: writes
     }, handle(config, async ({ project, environment, entityId, definition, policyOverride }) => {
         const normalized = normalizeWorkflowDefinition(definition);
         const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'create', workflowKind: 'automation' }, policyOverride));
-        const payload = await platform.tenant('POST', project, `/entities/${entityId}/automation`, { environment, body: definition });
-        return attachFindings(withNormalization(payload, normalized), findings);
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedEntityId = await resolveEntityId(resolver, entityId);
+        const payload = await platform.tenant('POST', project, `/entities/${resolvedEntityId}/automation`, { environment, body: definition });
+        return attachFindings(withResolved(withNormalization(payload, normalized), resolver.resolved), findings);
     }));
     server.registerTool('automation_update', {
         title: 'Automation güncelle',
-        description: "Automation tanımını günceller. definition = UpdateWorkflowCommand gövdesi ('automation' nesnesi içermeli); gövde politika kontrolünden geçer.",
-        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        description: "Automation tanımını günceller. definition = UpdateWorkflowCommand gövdesi ('automation' nesnesi içermeli); gövde politika kontrolünden geçer. " + constraintSummary('UpdateWorkflowCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: entityRef, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
         annotations: updates
     }, handle(config, async ({ project, environment, entityId, id, definition, policyOverride }) => {
         const normalized = normalizeWorkflowDefinition(definition);
         const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'update', workflowKind: 'automation' }, policyOverride));
-        const payload = await platform.tenant('PUT', project, `/entities/${entityId}/automation/${id}`, { environment, body: definition });
-        return attachFindings(withNormalization(payload, normalized), findings);
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedEntityId = await resolveEntityId(resolver, entityId);
+        const payload = await platform.tenant('PUT', project, `/entities/${resolvedEntityId}/automation/${id}`, { environment, body: definition });
+        return attachFindings(withResolved(withNormalization(payload, normalized), resolver.resolved), findings);
     }));
     server.registerTool('automation_delete', {
         title: 'Automation sil',
         description: 'Automation\'ı siler.',
-        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, id: guid },
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: entityRef, id: guid },
         annotations: destructive
-    }, handle(config, ({ project, environment, entityId, id }) => platform.tenant('DELETE', project, `/entities/${entityId}/automation/${id}`, { environment })));
+    }, handle(config, async ({ project, environment, entityId, id }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedEntityId = await resolveEntityId(resolver, entityId);
+        return withResolved(await platform.tenant('DELETE', project, `/entities/${resolvedEntityId}/automation/${id}`, { environment }), resolver.resolved);
+    }));
     server.registerTool('automation_reorder', {
         title: 'Automation sırasını değiştir',
         description: "Entity'nin automation'larının çalışma sırasını toplu günceller; aynı operasyona bağlı birden çok automation'da sıra davranışı belirler.",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
-            entityId: guid,
+            entityId: entityRef,
             automations: z.array(z.object({ id: guid, order: z.number().int().min(0) })).min(1)
                 .describe('Tüm automation\'lar için (id, order) çiftleri; listeyi automation_list ile kurun')
         },
         annotations: updates
-    }, handle(config, ({ project, environment, entityId, automations }) => platform.tenant('PUT', project, `/entities/${entityId}/automation/orders`, { environment, body: { automations } })));
+    }, handle(config, async ({ project, environment, entityId, automations }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedEntityId = await resolveEntityId(resolver, entityId);
+        return withResolved(await platform.tenant('PUT', project, `/entities/${resolvedEntityId}/automation/orders`, { environment, body: { automations } }), resolver.resolved);
+    }));
     server.registerTool('automation_trigger', {
         title: 'Automation tetikle',
-        description: 'Automation\'ı elle tetikler. Fire-and-forget çalışır: sonuç bu yanıtta dönmez, automation_histories ile izleyin.',
+        description: "Automation'ı elle tetikler — CANLI çalıştırır, gerçek satır yazar. Fire-and-forget: sonuç bu yanıtta dönmez, automation_histories + row_list ile izleyin. VERİ ÜRETMEK İÇİN KULLANMAYIN: rowContext almaz, bu yüzden yazdığı her zaman damgası UtcNow() olur — tarihsel bir tohumun üstünde tek bir doğrulama çağrısı huni ortalamasını bozar (B-52). Akışın ŞEKLİNİ sınamak istiyorsanız automation_preview kullanın: automation da bir workflow'dur, preview tek transaction'da koşar ve geri alınır, yani hiçbir satır kalmaz.",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
-            entityId: guid,
+            entityId: entityRef,
             id: guid,
             operation: z.string().optional(),
             recordIds: z.array(z.union([z.string(), z.number()])).optional().describe('Tetiklenecek satır id\'leri')
         },
         annotations: writes
-    }, handle(config, ({ project, environment, entityId, id, operation, recordIds }) => platform.tenant('POST', project, `/entities/${entityId}/automation/${id}/trigger`, {
-        environment,
-        body: { operation, recordIds: recordIds ?? [] }
-    })));
+    }, handle(config, async ({ project, environment, entityId, id, operation, recordIds }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedEntityId = await resolveEntityId(resolver, entityId);
+        return withResolved(await platform.tenant('POST', project, `/entities/${resolvedEntityId}/automation/${id}/trigger`, {
+            environment,
+            body: { operation, recordIds: recordIds ?? [] }
+        }), resolver.resolved);
+    }));
     server.registerTool('automation_histories', {
         title: 'Automation geçmişi',
         description: 'Automation çalıştırma geçmişini listeler; automation_trigger sonrası sonucu buradan doğrulayın.',
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
-            entityId: guid,
+            entityId: entityRef,
             id: guid,
             status: z.string().optional().describe('EventStatus filtresi'),
             ...pagingParams
         },
         annotations: readOnly
-    }, handle(config, ({ project, environment, entityId, id, ...query }) => platform.tenant('GET', project, `/entities/${entityId}/automation/${id}/histories`, { environment, query })));
+    }, handle(config, async ({ project, environment, entityId, id, ...query }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedEntityId = await resolveEntityId(resolver, entityId);
+        return withResolved(await platform.tenant('GET', project, `/entities/${resolvedEntityId}/automation/${id}/histories`, { environment, query }), resolver.resolved);
+    }));
     server.registerTool('automation_preview', {
         title: 'Automation önizle',
-        description: 'Kaydedilmemiş automation tanımını çalıştırır; kaydetmeden önce preview ile doğrulayın. definition = PreviewWorkflowCommand gövdesi.',
-        inputSchema: { project: projectParam, environment: environmentParam, entityId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        description: "Kaydedilmemiş automation tanımını çalıştırır; kaydetmeden önce preview ile doğrulayın. definition = PreviewWorkflowCommand gövdesi. Preview tek transaction'da koşar ve sonunda ROLLBACK edilir — kalıcı satır yazmaz (ölçüldü, İK koşusu W-1); code step'teki dış HTTP çağrıları istisnadır. Davranış kuralları: platform_guide('workflow').",
+        inputSchema: { project: projectParam, environment: environmentParam, entityId: entityRef, definition: definitionParam, policyOverride: policyOverrideParam, language: languageParam },
         annotations: writes
-    }, handle(config, async ({ project, environment, entityId, definition, policyOverride }) => {
+    }, handle(config, async ({ project, environment, entityId, definition, policyOverride, language }) => {
         const normalized = normalizeWorkflowDefinition(definition);
         const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'preview', workflowKind: 'automation' }, policyOverride));
-        const payload = await platform.tenant('POST', project, `/entities/${entityId}/automation/preview`, { environment, body: definition });
-        return attachFindings(withNormalization(payload, normalized), findings);
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedEntityId = await resolveEntityId(resolver, entityId);
+        const payload = await platform.tenant('POST', project, `/entities/${resolvedEntityId}/automation/preview`, { environment, body: definition, headers: languageHeader(language, normalized) });
+        return attachFindings(withResolved(withNormalization(payload, normalized), resolver.resolved), findings);
     }));
 }

package/dist/tools/common.js

@@ -1,11 +1,50 @@
+import { PlatformApiError } from '../platform/errors.js';
+import { isGuid } from '../platform/refs.js';
 import { z } from 'zod';
 export const guid = z.string().uuid();
+export const entityRef = z.string().min(1)
+    .describe("Entity id (GUID) ya da slug'ı ('employees' ya da 'BuiltIn/employees'); slug verilirse gateway id'ye çevirir ve yanıtta gatewayResolved ile bildirir");
+export const appRef = z.string().min(1)
+    .describe("Application id (GUID) ya da slug'ı; slug verilirse gateway id'ye çevirir ve yanıtta gatewayResolved ile bildirir");
+/** GUID verildiğinde ağaç HİÇ çekilmez — slug ek yoldur, mevcut GUID'li çağrıların maliyeti değişmez. */
+export async function resolveEntityId(resolver, ref) {
+    return isGuid(ref) ? ref : (await resolver.entity(ref)).entityId;
+}
+/**
+ * Kök `entityId`'yi hem `RefResolver.entity` hem `hydrateMicroserviceRefs` günlüğe yazar (biri
+ * çözümü, öteki gövdeye yazmayı bildirir) — aynı satır iki kez görünmesin diye tekilleştirilir.
+ */
+export function withResolved(payload, resolved) {
+    const unique = [...new Set(resolved)];
+    if (unique.length === 0)
+        return payload;
+    if (payload && typeof payload === 'object' && !Array.isArray(payload))
+        return { ...payload, gatewayResolved: unique };
+    return { data: payload, gatewayResolved: unique };
+}
 export const projectParam = z.string().min(1).optional()
     .describe('Proje slug\'ı; boşsa DEFAULT_PROJECT kullanılır');
 export const environmentParam = z.string().min(1).optional()
     .describe('Environment adı (X-Environment); boşsa DEFAULT_ENVIRONMENT kullanılır');
+export const languageParam = z.string().min(1).optional()
+    .describe("İstek dili (ISO 639-1, ör. 'en'); X-Data-Language olarak gider. Çok dilli alanlar bu dilde okunur/yazılır, workflow'da context.language ve ham sorguda {{language}} bu değeri alır. Verilmezse platform Accept-Language'a, o da yoksa projenin varsayılan diline düşer. Bölgeli değer ('tr-TR') kabul edilir ve gateway indirger.");
 export const definitionParam = z.record(z.unknown())
     .describe('API komut gövdesi birebir geçirilir; şablon için ilgili *_get çıktısını ya da ngapps://schemas kaynağını kullanın');
+/**
+ * Micro-op listesi iki adla dolaşıyordu: sayfa tool'ları `ops`, entity/microservice/workflow
+ * patch'leri `operations`. Ajan ikisini karıştırınca ilk çağrı şema hatasıyla düşüyordu
+ * (09-04 Y-07). İki ad da her yerde kabul edilir; ikisi birden verilirse çağrı durur.
+ */
+export function microOps(tool, ops, operations) {
+    if (ops !== undefined && operations !== undefined) {
+        throw new PlatformApiError(`${tool}: 'ops' ve 'operations' birlikte verilemez — ikisi aynı listenin iki adıdır, hangisinin geçerli olduğu belirsiz kalır. Birini seçin.`, 400);
+    }
+    const resolved = ops ?? operations;
+    if (resolved === undefined || resolved.length === 0) {
+        throw new PlatformApiError(`${tool}: uygulanacak micro-op listesi boş — 'ops' (ya da eşanlamlısı 'operations') en az bir op taşımalı.`, 400);
+    }
+    return resolved;
+}
 export const pagingParams = {
     pageIndex: z.number().int().min(0).optional().describe('0 tabanlı sayfa numarası'),
     pageLength: z.number().int().min(1).max(200).optional().describe('Sayfa boyu; platform varsayılanı 10'),

package/dist/tools/components.js

@@ -1,7 +1,7 @@
 import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive } from './common.js';
-import { normalizeComponentDefaults, componentDefaultsNote, clampBlockSizes, blockSizeNote, normalizeHeightTypes, heightTypeNote, withNormalization } from '../knowledge/normalize.js';
+import { normalizeComponentDefaults, componentDefaultsNote, clampBlockSizes, blockSizeNote, normalizeHeightTypes, heightTypeNote, normalizeSizeStrings, sizeStringNote, withNormalization } from '../knowledge/normalize.js';
 import { eventContractsFor, eventPayloadNote } from '../knowledge/componentEvents.js';
-import { knowledgeFor, knowledgeNote } from '../knowledge/componentCatalog.js';
+import { knowledgeFor, knowledgeNote, APPEARANCE_TOKEN_SETS, STATE_FLAG_NOTES, INTERNAL_ROLES_BY_TYPE } from '../knowledge/componentCatalog.js';
 import { componentUpdateBody, fetchHost, schemaParam, unwrap } from './screens.js';
 import { PlatformApiError } from '../platform/errors.js';
 import { handle } from '../platform/responses.js';
@@ -72,10 +72,10 @@ export function componentLayoutRules(components) {
 export async function applyCatalogLayoutRules(platform, project, environment, applicationId, nodes) {
     try {
         const rules = await fetchComponentLayoutRules(platform, project, environment, applicationId);
-        return { clamped: clampBlockSizes(nodes, rules.maxSizes), heights: normalizeHeightTypes(nodes, rules.autoHeights) };
+        return { clamped: clampBlockSizes(nodes, rules.maxSizes), heights: normalizeHeightTypes(nodes, rules.autoHeights), sizes: normalizeSizeStrings(nodes) };
     }
     catch {
-        return { clamped: [], heights: normalizeHeightTypes(nodes, new Map()) };
+        return { clamped: [], heights: normalizeHeightTypes(nodes, new Map()), sizes: normalizeSizeStrings(nodes) };
     }
 }
 /**
@@ -182,6 +182,14 @@ export function registerComponentTools(server, platform) {
                     ...(knowledge.guide ? { guide: knowledge.guide } : {})
                 }
                 : { knowledgeNote }),
+            ...(componentSlug && INTERNAL_ROLES_BY_TYPE[componentSlug]
+                ? {
+                    internalRoles: INTERNAL_ROLES_BY_TYPE[componentSlug],
+                    internalRolesNote: "Bu komponentin İÇ kontrolleri dışarıdan adreslenebilir: page_screenshot actions hedefine '<elementId>__<rol>' yazın (ör. 'tbl_vacancy__pager-next'). Kimlikler runtime'ın data-element-id özniteliğidir; ikinci bir mekanizma yoktur."
+                }
+                : {}),
+            appearanceValues: APPEARANCE_TOKEN_SETS,
+            stateFlags: STATE_FLAG_NOTES,
             validations: definition.validations,
             sizes: definition.blocks
         };
@@ -217,7 +225,7 @@ export function registerComponentTools(server, platform) {
         const fixed = normalizeComponentDefaults(body.schema);
         const catalog = (body.schema ?? []).length > 0
             ? await applyCatalogLayoutRules(platform, project, environment, applicationId, body.schema)
-            : { clamped: [], heights: [] };
+            : { clamped: [], heights: [], sizes: [] };
         return platform.tenant('POST', project, `/components/${applicationId}`, {
             environment,
             body: {
@@ -228,7 +236,7 @@ export function registerComponentTools(server, platform) {
                 schema: [],
                 ...Object.fromEntries(Object.entries(body).filter(([, value]) => value !== undefined))
             }
-        }).then(response => withNormalization(response, [...componentDefaultsNote(fixed), ...blockSizeNote(catalog.clamped), ...heightTypeNote(catalog.heights)]));
+        }).then(response => withNormalization(response, [...componentDefaultsNote(fixed), ...blockSizeNote(catalog.clamped), ...heightTypeNote(catalog.heights), ...sizeStringNote(catalog.sizes)]));
     }));
     server.registerTool('component_update', {
         title: 'Komponent güncelle',
@@ -267,9 +275,10 @@ export function registerComponentTools(server, platform) {
         const rules = componentLayoutRules(components);
         const clamped = overrides.schema === undefined ? [] : clampBlockSizes(overrides.schema, rules.maxSizes);
         const heights = overrides.schema === undefined ? [] : normalizeHeightTypes(overrides.schema, rules.autoHeights);
+        const sizes = overrides.schema === undefined ? [] : normalizeSizeStrings(overrides.schema);
         const body = componentUpdateBody({ ...detailed, applicationId }, overrides);
         await platform.tenant('PUT', project, `/components/${applicationId}/${slug}`, { environment, body });
-        return withNormalization({ slug, changed: Object.keys(overrides), preserved: { schemaNodes: body.schema.length } }, [...componentDefaultsNote(fixed), ...blockSizeNote(clamped), ...heightTypeNote(heights)]);
+        return withNormalization({ slug, changed: Object.keys(overrides), preserved: { schemaNodes: body.schema.length } }, [...componentDefaultsNote(fixed), ...blockSizeNote(clamped), ...heightTypeNote(heights), ...sizeStringNote(sizes)]);
     }));
     server.registerTool('component_delete', {
         title: 'Komponent sil',

package/dist/tools/datasources.js

@@ -1,21 +1,58 @@
 import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { withNormalization } from '../knowledge/normalize.js';
+import { PlatformApiError } from '../platform/errors.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';
+import { constraintSummary } from '../knowledge/backendConstraints.js';
+/**
+ * B-56 — tam yanıtın %79'u (35.645 / 45.026 karakter, 2026-09-07 ölçümü) 816 satırlık ICU
+ * collation sözlüğü. Ajanın alan tipi kararına giren şey collation DEĞERLERİ değil, tipin
+ * collation KABUL ETTİĞİ bilgisidir ve o zaten options anahtarında duruyor.
+ *
+ * Backend'in özet ucu (b-12) aynı projeksiyonu sunucu tarafında yapar; bu fonksiyon o uç
+ * bulunmayan sürümler için aynı şekli tam yanıttan üretir. Eleme ve düzleştirme dışında bir şey
+ * yapmaz — tam yanıtta olmayan hiçbir alanı uydurmaz.
+ */
+function configurationSummary(body) {
+    const groups = new Map();
+    for (const group of body.dataTypes ?? []) {
+        const key = String(group.commonType ?? '');
+        const merged = groups.get(key) ?? { commonType: group.commonType, defaultDbType: undefined, types: [] };
+        for (const type of group.types ?? []) {
+            if (merged.defaultDbType === undefined && type.isDefault === true)
+                merged.defaultDbType = type.dbType;
+            merged.types.push({
+                dbType: type.dbType,
+                options: (type.options ?? []).map(option => option.key),
+                convertibleTypes: type.convertibleTypes ?? []
+            });
+        }
+        groups.set(key, merged);
+    }
+    const definitions = Object.fromEntries(Object.entries(body.definitions ?? {})
+        .filter(([name]) => name !== 'collation')
+        .map(([name, entries]) => [name, (entries ?? []).map(entry => entry.value)]));
+    return { dataTypes: [...groups.values()], definitions: definitions };
+}
+// Sınırlar CreateDatasourceCommandValidator / UpdateDatasourceCommandValidator'ın aynasıdır (DS-001):
+// dbName ve host backend'de NotNull().NotEmpty() — eski 'optional' şekil her çağrıda 422 yiyordu.
 const connectionInput = {
-    name: z.string().min(1),
-    description: z.string().optional(),
-    dbName: z.string().optional(),
-    type: z.string().describe('DatasourceType (ör. Postgres); datasource_resources tool\'u geçerli tipleri listeler'),
-    host: z.string().optional(),
-    port: z.number().int().optional(),
-    properties: z.record(z.unknown()).optional(),
+    name: z.string().min(1).max(50).describe('En fazla 50 karakter'),
+    description: z.string().max(255).optional().describe('En fazla 255 karakter'),
+    dbName: z.string().min(1).max(63).describe('Bağlanılacak veritabanı adı; zorunlu, en fazla 63 karakter'),
+    type: z.enum(['postgresql', 'mongodb']).describe("DatasourceType, küçük harf: 'postgresql' | 'mongodb'; yapılandırma ayrıntısı datasource_resources"),
+    host: z.string().min(1).max(255).describe('Zorunlu, en fazla 255 karakter'),
+    port: z.number().int().min(0).max(65535).optional(),
+    properties: z.record(z.unknown()).optional().describe("postgresql: { initialDatabase ≤63, userName ≤63, password ≤1024 } üçü zorunlu · mongodb: { authenticationType: none|password|ldap|kerberos|x.509, … }; 'password' iken authenticationDatabase/userName/password zorunlu (DS-001)"),
     connectionOptions: z.record(z.string()).optional()
 };
 export function registerDatasourceTools(server, platform) {
     const config = platform.config;
     server.registerTool('datasource_list', {
         title: 'Datasource listele',
-        description: 'Projedeki datasource\'ları listeler; tree=true entity ağacıyla birlikte döner.',
+        description: "Projedeki datasource'ları listeler; tree=true entity ağacıyla birlikte döner. isBuiltIn: true olan kayıt projenin KENDİ veritabanıdır ve entity'ler oraya açılır; bu bayrak yalnız tree'siz listede döner (ağaç ucu taşımaz) — ağaçla çalışırken built-in'i project_overview çıktısından tanıyın.",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
@@ -28,38 +65,44 @@ export function registerDatasourceTools(server, platform) {
     }, handle(config, ({ project, environment, tree, ...query }) => platform.tenant('GET', project, tree ? '/datasources/tree' : '/datasources', { environment, query })));
     server.registerTool('datasource_get', {
         title: 'Datasource getir',
-        description: 'Tek datasource\'u id ile getirir.',
+        description: "Tek datasource'u id ile getirir. Parola yanıtta gateway tarafından maskelenir (gatewayMasked); built-in datasource'un kimlik bilgisi hiçbir tool'dan okunamaz ve entity açmak için gerekmez.",
         inputSchema: { project: projectParam, environment: environmentParam, id: guid },
         annotations: readOnly
     }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/datasources/${id}`, { environment })));
     server.registerTool('datasource_create', {
         title: 'Datasource oluştur',
-        description: 'Projeye yeni datasource ekler; önce datasource_test_connection ile bağlantıyı doğrulamak iyi pratiktir.',
+        description: "Projeye YENİ BİR DIŞ veritabanı bağlar. YALNIZ kullanıcı kendi veritabanını verdiğinde çağırın (host/port/kullanıcı/parola elinizde). Her proje project_create ile birlikte kendi veritabanını ve silinemez bir built-in datasource'unu alır; entity'ler, hazır users/roles tabloları ve işlerin çoğu oradadır — datasource_list çıktısında isBuiltIn: true olan kayıt odur. Temiz bir isim alanı istiyorsanız datasource değil YENİ PROJE açın: veritabanı proje başına, şema environment başına ayrılır; tek datasource içinde şema/önek vermenin yolu yoktur. Parola zorunludur ve built-in'inki hiçbir tool'dan okunamaz — kimlik bilgisi elinizde yoksa bu tool'un yeri yoktur. Bağlantıyı önce datasource_test_connection ile doğrulayın. " + constraintSummary('CreateDatasourceCommand'),
         inputSchema: { project: projectParam, environment: environmentParam, ...connectionInput },
         annotations: writes
-    }, handle(config, ({ project, environment, ...body }) => platform.tenant('POST', project, '/datasources', { environment, body })));
+    }, handle(config, async ({ project, environment, ...body }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'datasource', body, { operation: 'create' }));
+        return attachFindings(await platform.tenant('POST', project, '/datasources', { environment, body }), findings);
+    }));
     server.registerTool('datasource_update', {
         title: 'Datasource güncelle',
-        description: 'Datasource bağlantı bilgilerini günceller.',
+        description: "Dış bir datasource'un bağlantı bilgilerini günceller; YALNIZ kullanıcı yeni bağlantı bilgisi verdiğinde çağırın. Built-in datasource'ta bu çağrı SESSİZCE DÜŞER: platform yalnız connectionOptions'ı yazar, name/host/port/dbName/properties atılır ve çağrı yine 200 döner (DatasourceService.UpdateAsync). " + constraintSummary('UpdateDatasourceCommand'),
         inputSchema: { project: projectParam, environment: environmentParam, id: guid, ...connectionInput },
         annotations: updates
-    }, handle(config, ({ project, environment, id, ...body }) => platform.tenant('PUT', project, `/datasources/${id}`, { environment, body })));
+    }, handle(config, async ({ project, environment, id, ...body }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'datasource', body, { operation: 'update' }));
+        return attachFindings(await platform.tenant('PUT', project, `/datasources/${id}`, { environment, body }), findings);
+    }));
     server.registerTool('datasource_delete', {
         title: 'Datasource sil',
-        description: 'Datasource\'u siler; altındaki entity tanımları da etkilenir.',
+        description: "Datasource'u siler; altındaki entity tanımları da etkilenir. Projenin built-in datasource'u SİLİNEMEZ (BuiltInDatasourceCannotDeletedException).",
         inputSchema: { project: projectParam, environment: environmentParam, id: guid },
         annotations: destructive
     }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/datasources/${id}`, { environment })));
     server.registerTool('datasource_test_connection', {
         title: 'Bağlantıyı test et',
-        description: "Kayıtlı datasource için 'id', kaydedilmemiş bağlantı için type/host/port alanlarını verin.",
+        description: "Kullanıcının verdiği bir DIŞ bağlantıyı datasource_create öncesi doğrular: kayıtlı datasource için 'id', kaydedilmemiş bağlantı için type/host/port alanlarını verin. Built-in datasource'u test etmenin anlamı yoktur — bağlantısını platform kurar ve parolası hiçbir tool'dan okunamaz.",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
             id: guid.optional(),
-            type: z.string().optional(),
-            host: z.string().optional(),
-            port: z.number().int().optional(),
+            type: z.enum(['postgresql', 'mongodb']).optional(),
+            host: z.string().min(1).max(255).optional().describe("'id' verilmediyse zorunlu; en fazla 255 karakter (TestConnectionCommandValidator)"),
+            port: z.number().int().min(0).max(65535).optional(),
             properties: z.record(z.unknown()).optional(),
             connectionOptions: z.record(z.string()).optional()
         },
@@ -75,8 +118,27 @@ export function registerDatasourceTools(server, platform) {
     }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/datasources/resources', { environment })));
     server.registerTool('datasource_configuration_options', {
         title: 'Yapılandırma seçenekleri',
-        description: 'Kayıtlı datasource\'un tipine özel yapılandırma seçeneklerini döner.',
-        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        description: "Datasource'un alan tipi kataloğunu döner: commonType başına dbType listesi, varsayılan tip, tipin kabul ettiği seçenek anahtarları (length/precision/collation/...) ve dönüştürülebilir tipler; ayrıca ilişki kuralları (onUpdate/onDelete) ve identity generation tipleri. VARSAYILAN YANIT ÖZETTİR (~5 KB): collation DEĞER listesi (816 kayıt, tam yanıtın %79'u) dışarıdadır — tipin collation kabul edip etmediği zaten options'ta yazar. Collation değerleri gerçekten gerekiyorsa includeCollations: true ile tam yanıtı isteyin (~45 KB).",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            includeCollations: z.boolean().optional()
+                .describe("true: platformun tam yanıtı döner (816 kayıtlık collation sözlüğü dâhil, ~45 KB). Yalnız bir alana collation SEÇECEKSENİZ gerekir.")
+        },
         annotations: readOnly
-    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/datasources/${id}/configuration-options`, { environment })));
+    }, handle(config, async ({ project, environment, id, includeCollations }) => {
+        if (includeCollations)
+            return platform.tenant('GET', project, `/datasources/${id}/configuration-options`, { environment });
+        try {
+            return await platform.tenant('GET', project, `/datasources/${id}/configuration-options/summary`, { environment });
+        }
+        catch (error) {
+            // Yalnız "uç yok" durumunda yedek yola düşülür; başka hata yutulmaz.
+            if (!(error instanceof PlatformApiError) || error.status !== 404)
+                throw error;
+        }
+        const full = await platform.tenant('GET', project, `/datasources/${id}/configuration-options`, { environment });
+        return withNormalization({ data: configurationSummary(full?.data ?? {}) }, ["özet ucu bu backend sürümünde YOK (404): tam yanıt çekilip özet gateway tarafında üretildi — collation DEĞERLERİ düştü, geri kalan alanlar dokunulmadan geldi. Değerler gerekiyorsa includeCollations: true."]);
+    }));
 }

package/dist/tools/deployments.js

@@ -10,8 +10,40 @@ export function registerDeploymentTools(server, platform) {
     }, handle(config, ({ projectId, ...body }) => platform.org('POST', `/deployments/${projectId}/deploy`, { body })));
     server.registerTool('deployment_status', {
         title: 'Deployment durumu',
-        description: 'Projenin son deployment durumunu döner.',
+        description: "Projenin son deployment durumunu döner. 'projectId' ZORUNLUDUR (project_list/project_get'ten alın) — verilmezse çağrı MCP şema katmanında reddedilir, platforma hiç gitmez. Hiç deployment yapılmamış projede yanıt BOŞ gelir; o durumda tool 'hiç deployment kaydı yok' bilgisini açıkça döner, yani boş yanıtı 'tool çalışmadı' diye okumayın.",
         inputSchema: { projectId: guid },
         annotations: readOnly
-    }, handle(config, ({ projectId }) => platform.org('GET', `/deployments/${projectId}`)));
+    }, handle(config, async ({ projectId }) => {
+        const payload = await platform.org('GET', `/deployments/${projectId}`);
+        const record = payload && typeof payload === 'object' ? payload : undefined;
+        const data = record?.data;
+        // Platform hiç kayıt yokken `{"data":null,"message":null}` döner. Eski kural yalnız `data`
+        // ANAHTARI HİÇ YOKSA zarfa bakıyordu; `data: null` + `message: null` iki anahtar saydığı için
+        // "dolu" görünüyor, yanıt olduğu gibi geçiyor ve null'lar süzülünce tool 2 BAYT dönüyordu
+        // (2026-09-06 çağrı #181 — S-11 · B-36'nın üçüncü ölçümü).
+        const isEmpty = data === undefined || data === null
+            ? Object.values(record ?? {}).every(value => value === null || value === undefined)
+            : Array.isArray(data) ? data.length === 0 : Object.keys(data).length === 0;
+        // "Tool çalışmadı" ile "kayıt yok" boş `{}` yanıtında ayırt edilemiyordu (09-05 S-10).
+        if (!isEmpty)
+            return payload;
+        // Environment listesi BİR EK istek: 2026-09-06 koşusu deployment_start'ı atlayabilmek için
+        // tam olarak bu bilgiyi ayrı bir project_get turuyla aldı, yani ek istek bir tur EKLEMİYOR,
+        // bir turu buraya taşıyor. Okunamazsa boş sonuç sözleşmesi yine döner.
+        const project = await platform.org('GET', `/projects/${projectId}`).catch(() => undefined);
+        const projectData = project?.data;
+        const environments = Array.isArray(projectData?.environments)
+            ? projectData.environments.map(entry => ({
+                id: entry.id,
+                name: entry.name,
+                isProduction: entry.isProduction === true
+            }))
+            : undefined;
+        return {
+            projectId,
+            deployments: [],
+            note: "Bu projede hiç deployment kaydı yok — çağrı BAŞARILI, sonuç boş. Deployment başlatmak için deployment_start (kaynak/hedef environment id'leri aşağıdaki environments listesindedir).",
+            ...(environments ? { environments } : {})
+        };
+    }));
 }

package/dist/tools/dtos.js

@@ -1,6 +1,12 @@
 import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { writeDiff, withWriteDiff } from '../platform/writeDiff.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';
+import { constraintSummary } from '../knowledge/backendConstraints.js';
+const policyOverrideParam = z.boolean().optional()
+    .describe('true: politika block bulgularını warn\'a indirir (bilinçli istisna; yanıtta işaretlenir)');
 export function registerDtoTools(server, platform) {
     const config = platform.config;
     server.registerTool('dto_list', {
@@ -23,28 +29,35 @@ export function registerDtoTools(server, platform) {
     }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/datatransferobjects/${id}/scheme`, { environment })));
     server.registerTool('dto_create', {
         title: 'DTO oluştur',
-        description: "Yeni DataTransferObject tanımlar (definition = CreateDataTransferObjectCommand). Workflow'un parameterDtoId/returnDtoId sözleşmeleri buradan çıkar; şablon için dto_get kullanın.",
-        inputSchema: { project: projectParam, environment: environmentParam, definition: definitionParam },
+        description: "Yeni DataTransferObject tanımlar (definition = CreateDataTransferObjectCommand). Workflow'un parameterDtoId/returnDtoId sözleşmeleri buradan çıkar; şablon için dto_get kullanın. " + constraintSummary('CreateDataTransferObjectCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, definition: definitionParam, policyOverride: policyOverrideParam },
         annotations: writes
-    }, handle(config, ({ project, environment, definition }) => platform.tenant('POST', project, '/datatransferobjects', { environment, body: definition })));
+    }, handle(config, async ({ project, environment, definition, policyOverride }) => {
+        // G-23: 09-05 koşusunda çocuk alanın `type: "text"` değeri sessizce `object`'e çevrildi ve
+        // bu ancak platformun kendi ürettiği bir DTO okunarak fark edildi. Doğrusu `"string"` —
+        // DTO-001 tip sözlüğünü artık istek gitmeden denetler.
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'dto', definition, { operation: 'create' }, policyOverride));
+        const payload = await platform.tenant('POST', project, '/datatransferobjects', { environment, body: definition });
+        return attachFindings(withWriteDiff(payload, writeDiff(definition, payload)), findings);
+    }));
     server.registerTool('dto_update', {
         title: 'DTO güncelle',
-        description: 'DTO tanımını günceller (definition = UpdateDataTransferObjectCommand); mevcut hâli dto_get ile alın.',
-        inputSchema: { project: projectParam, environment: environmentParam, id: guid, definition: definitionParam },
+        description: 'DTO tanımını günceller (definition = UpdateDataTransferObjectCommand); mevcut hâli dto_get ile alın. ' + constraintSummary('UpdateDataTransferObjectCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
         annotations: updates
-    }, handle(config, ({ project, environment, id, definition }) => platform.tenant('PUT', project, `/datatransferobjects/${id}`, { environment, body: definition })));
+    }, handle(config, async ({ project, environment, id, definition, policyOverride }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'dto', definition, { operation: 'update' }, policyOverride));
+        const payload = await platform.tenant('PUT', project, `/datatransferobjects/${id}`, { environment, body: definition });
+        return attachFindings(withWriteDiff(payload, writeDiff(definition, payload)), findings);
+    }));
     server.registerTool('dto_clone', {
         title: 'DTO klonla',
         description: "DTO'nun kopyasını oluşturur.",
         inputSchema: { project: projectParam, environment: environmentParam, id: guid },
         annotations: writes
     }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/datatransferobjects/${id}/clone`, { environment })));
-    server.registerTool('dto_sync_primitives', {
-        title: 'İlkel DTO tiplerini senkronla',
-        description: "Platformun ilkel (primitive) DTO tanımlarını projeye yeniden yazar; DTO listesinde temel tipler eksikse çalıştırılır. Bakım işidir.",
-        inputSchema: { project: projectParam, environment: environmentParam },
-        annotations: updates
-    }, handle(config, ({ project, environment }) => platform.tenant('POST', project, '/datatransferobjects/sync-primitives', { environment })));
+    // `POST /datatransferobjects/sync-primitives` de bir BAKIM ucudur (yukarıdaki sync-users ile
+    // aynı sınıf); araç olarak yayınlanmıyor.
     server.registerTool('dto_delete', {
         title: 'DTO sil',
         description: "DTO'yu siler; workflow/query'lerde referans varsa platform reddeder.",