editmamei 1.0.3 → 1.2.0

package/dist/tools/selection-tools.js

@@ -2,10 +2,10 @@ import { readFile } from 'node:fs/promises';
 import { runScript } from '../utils/run-script.js';
 import { TempDir } from '../utils/temp.js';
 import { validateArgs } from '../utils/validate.js';
-import { toolErrorResult, runSnippetTool } from '../utils/tool-helpers.js';
+import { toolErrorResult, runSnippetTool, unknownDiscriminator } from '../utils/tool-helpers.js';
 import { OnnxLandmarkDetectionClient } from '../detection/landmark-detection-client.js';
 import { resolveExpectedPlacement, PLACEMENT_SCHEMA } from '../perception/grounding-locate.js';
-import { SELECT_SUBJECT_TIMEOUT_MS, SELECT_SKY_TIMEOUT_MS } from '../utils/operation-timeouts.js';
+import { SELECT_SUBJECT_TIMEOUT_MS, SELECT_SKY_TIMEOUT_MS, SELECT_FOCUS_AREA_TIMEOUT_MS, } from '../utils/operation-timeouts.js';
 export const SELECTION_TYPE_ENUM = ['replace', 'add', 'subtract', 'intersect'];
 export const selectionTypeFragment = {
     type: 'string',
@@ -450,8 +450,8 @@ const SELECT_INPUT_SCHEMA = {
                 'color_range: target red/green/blue (+fuzziness) — "select all the red / skin". ' +
                 'luminance_range: luminance highlights|shadows|midtones (+fuzziness, lower_limit, upper_limit) — glow/dodge-burn foundation. ' +
                 'magic_wand: click x/y (+tolerance, contiguous, anti_alias, sample_all_layers). ' +
-                'grow: expand the CURRENT selection to adjacent similar-colour pixels (+tolerance, anti_alias). ' +
-                'similar: expand the CURRENT selection to ALL similar-colour pixels document-wide (+tolerance, anti_alias). ' +
+                'grow: DEPRECATED here — use ps_modify_selection(op=grow) instead (kept for one release for backward compatibility, identical behaviour). Expands the CURRENT selection to adjacent similar-colour pixels (+tolerance, anti_alias). ' +
+                'similar: DEPRECATED here — use ps_modify_selection(op=similar) instead (kept for one release for backward compatibility, identical behaviour). Expands the CURRENT selection to ALL similar-colour pixels document-wide (+tolerance, anti_alias). ' +
                 'skin_tones: select skin-coloured pixels (+fuzziness; use_faces=true adds face-aware refinement). ' +
                 'out_of_gamut: select colours outside the printable CMYK gamut (no params). ' +
                 'polygon: points [{x,y},...] in ABSOLUTE document pixels (min 3, auto-closes) — covers polygonal/freehand lasso. Coordinate-driven: you must know the pixel positions (use ps_inspect / ps_get_preview to aim, or ps_path create_from_placement → load_as_selection for a grounded outline). ' +
@@ -479,6 +479,8 @@ const MODIFY_SELECTION_OPS = [
     'border',
     'smooth',
     'transform',
+    'grow',
+    'similar',
 ];
 const MODIFY_SELECTION_INPUT_SCHEMA = {
     type: 'object',
@@ -491,13 +493,16 @@ const MODIFY_SELECTION_INPUT_SCHEMA = {
                 'expand: grow the selection outward by `amount` px. contract: shrink it inward by `amount` px. ' +
                 'border: replace the selection with a `amount`-px-wide band straddling its edge. ' +
                 'smooth: round off the selection corners with a `amount`-px radius. ' +
+                'grow: expand the selection to adjacent similar-colour pixels (+tolerance, anti_alias). ' +
+                'similar: expand the selection to ALL similar-colour pixels document-wide (+tolerance, anti_alias). ' +
                 'transform: relatively scale (scale_x_percent / scale_y_percent), rotate (rotate_degrees) and/or translate (offset_x / offset_y) the marching ants — not pixels. ' +
-                'expand/contract/border/smooth all require an active selection and take `amount`; expand/contract/smooth also take at_canvas_bounds.',
+                'expand/contract/border/smooth all require an active selection and take `amount`; expand/contract/smooth also take at_canvas_bounds. grow/similar also require an active selection.',
         },
         ...featherSelectionSchema.properties,
         ...refineEdgeSchema.properties,
         ...modifyEdgeSchema.properties,
         ...transformSelectionSchema.properties,
+        ...growSelectionSchema.properties,
     },
     required: ['op'],
 };
@@ -575,7 +580,7 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
         {
             tool: {
                 name: 'ps_select',
-                description: 'Create or modify a selection — choose with `mode`. `all` selects the canvas; `none` deselects; `inverse` inverts the current selection (e.g. select the subject, then inverse to act on the background). `rectangle` (left/top/right/bottom, optional feather_px to avoid hard block-edges in smooth sky). `ellipse` (left/top/right/bottom bounding box + anti_alias — circles/ovals). `color_range` (target red/green/blue + fuzziness — "select all the red / skin tones"). `luminance_range` (highlights/shadows/midtones — foundation for glow / dodge-burn). `magic_wand` (click x/y + tolerance, contiguous). `grow` / `similar` expand the CURRENT selection to similar-colour pixels (adjacent vs document-wide; both honour `tolerance`). rectangle/ellipse/magic_wand also accept a grounded `placement` (NAME a region/point instead of guessing pixels — resolved + gate-verified). The geometric/color/wand modes take selection_type (replace|add|subtract|intersect) to combine with an existing selection and return a rich selection_info bundle — verify it (or ps_get_selection_preview) before committing to a mask.',
+                description: 'Create a NEW selection — choose with `mode`. (To edit the CURRENT selection instead — including growing it by colour similarity — use ps_modify_selection.) `all` selects the canvas; `none` deselects; `inverse` inverts the current selection (e.g. select the subject, then inverse to act on the background). `rectangle` (left/top/right/bottom, optional feather_px to avoid hard block-edges in smooth sky). `ellipse` (left/top/right/bottom bounding box + anti_alias — circles/ovals). `color_range` (target red/green/blue + fuzziness — "select all the red / skin tones"). `luminance_range` (highlights/shadows/midtones — foundation for glow / dodge-burn). `magic_wand` (click x/y + tolerance, contiguous). `grow` / `similar` are DEPRECATED here (they act on the CURRENT selection, not a new one) — use ps_modify_selection(op=grow|similar) instead; kept for one release for backward compatibility, identical behaviour. rectangle/ellipse/magic_wand also accept a grounded `placement` (NAME a region/point instead of guessing pixels — resolved + gate-verified). The geometric/color/wand modes take selection_type (replace|add|subtract|intersect) to combine with an existing selection and return a rich selection_info bundle — verify it (or ps_get_selection_preview) before committing to a mask.',
                 inputSchema: SELECT_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',
@@ -614,7 +619,7 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
         {
             tool: {
                 name: 'ps_modify_selection',
-                description: "Modify the CURRENT selection — choose with `op`. `feather` softens by radius_px (use when a selection was made hard, e.g. after select all/inverse, before applying an adjustment). `refine_edge` runs Select-and-Mask's global sliders headlessly (smooth, feather, contrast, shift_edge, edge-detection radius, decontaminate) to clean halos and soft/fuzzy edges (hair) after a rough color-range / magic-wand / subject selection. `expand` / `contract` grow / shrink the selection by `amount` px. `border` replaces the selection with an `amount`-px band around its edge. `smooth` rounds the corners with an `amount`-px radius. `transform` relatively scales (scale_x_percent / scale_y_percent), rotates (rotate_degrees) and/or translates (offset_x / offset_y) the marching ants — pixels are untouched. All require an active selection and return selection_info.",
+                description: "Modify the CURRENT selection — choose with `op`. (To create a NEW selection instead, use ps_select.) `feather` softens by radius_px (use when a selection was made hard, e.g. after select all/inverse, before applying an adjustment). `refine_edge` runs Select-and-Mask's global sliders headlessly (smooth, feather, contrast, shift_edge, edge-detection radius, decontaminate) to clean halos and soft/fuzzy edges (hair) after a rough color-range / magic-wand / subject selection. `expand` / `contract` grow / shrink the selection by `amount` px. `border` replaces the selection with an `amount`-px band around its edge. `smooth` rounds the corners with an `amount`-px radius. `grow` / `similar` expand the selection to similar-colour pixels by `tolerance` (+anti_alias) — `grow` to adjacent pixels only, `similar` document-wide. `transform` relatively scales (scale_x_percent / scale_y_percent), rotates (rotate_degrees) and/or translates (offset_x / offset_y) the marching ants — pixels are untouched. All require an active selection and return selection_info.",
                 inputSchema: MODIFY_SELECTION_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',
@@ -623,6 +628,8 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
                         refined: { type: 'boolean' },
                         modified: { type: 'boolean' },
                         transformed: { type: 'boolean' },
+                        selected: { type: 'boolean', description: 'op=grow/similar: true on success.' },
+                        method: { type: 'string', description: 'op=grow/similar: "grow" or "similar".' },
                         mode: { type: 'string' },
                         amount_px: { type: 'number' },
                         scale_x_percent: { type: 'number' },
@@ -637,6 +644,8 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
                         contrast: { type: 'number' },
                         shift_edge: { type: 'number' },
                         decontaminate: { type: 'boolean' },
+                        tolerance: { type: 'number', description: 'op=grow/similar: tolerance used.' },
+                        anti_alias: { type: 'boolean', description: 'op=grow/similar: anti_alias used.' },
                         output: { type: 'string' },
                         selection_info: selectionInfoFragment,
                     },
@@ -808,6 +817,42 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
             },
             handler: async (args) => selectSky(connection, snippetClient, args),
         },
+        {
+            tool: {
+                name: 'ps_select_focus_area',
+                description: "Run Photoshop's \"Focus Area\" — select what the lens rendered SHARP, by depth of field rather than by subject or colour. Use it when the thing you want is defined by focus and not by what it is: lifting a subject off a bokeh background, masking the in-focus plane of a macro shot, or grabbing a shallow-depth foreground that Select Subject splits badly. Takes NO coordinates. in_focus_radius widens (higher) or narrows (lower) what counts as sharp; soft_mask=true gives feathered edges instead of a hard boundary. Analyses the ACTIVE layer, so target the photographic pixels you mean. If the active layer is not a raster layer at all (adjustment, smart object, text, shape), detection is retargeted to the bottom layer and active_layer_temporarily_changed comes back true — check it, because the analysed layer was then NOT the one you selected. An EMPTY raster layer cannot be told apart by kind, so it is not retargeted; it surfaces instead as an error or as whole_canvas_selected. whole_canvas_selected and warning diagnose Focus Area's RAW detection, measured BEFORE any selection_type combine — a uniformly sharp image (or too high an in_focus_radius) trips them even when combining then folds the result down to something small. Check whole_canvas_selected first; selection_info separately reports the FINAL, post-combine selection and can disagree with it by design (e.g. selection_type='subtract' against an existing selection), so read selection_info for what actually got selected, not as a substitute for whole_canvas_selected.",
+                inputSchema: selectFocusAreaSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        selected: { type: 'boolean' },
+                        method: { type: 'string' },
+                        strategy_used: { type: 'string' },
+                        in_focus_radius: { type: 'number' },
+                        soft_mask: { type: 'boolean' },
+                        active_layer_temporarily_changed: {
+                            type: 'boolean',
+                            description: 'True if the active layer was not an ordinary pixel layer and detection was temporarily retargeted to the bottom layer. The original active layer is restored before return.',
+                        },
+                        whole_canvas_selected: {
+                            type: 'boolean',
+                            description: "True when Focus Area's RAW detection covered essentially the entire canvas — usually a non-result (radius too high, or nothing photographic to analyse). Measured BEFORE combining with any prior selection, so it describes the detection step, not the final selection: selection_info reports the FINAL, post-combine result and the two can legitimately disagree, e.g. selection_type='subtract' against an existing selection can leave this true while selection_info.area_percent is well under 100.",
+                        },
+                        warning: {
+                            type: ['string', 'null'],
+                            description: 'Set when whole_canvas_selected is true. Also describes the RAW detection, not the final post-combine selection.',
+                        },
+                        selection_type: { type: 'string' },
+                        selection_info: selectionInfoFragment,
+                    },
+                },
+                annotations: {
+                    title: 'Select Focus Area',
+                    idempotentHint: true,
+                },
+            },
+            handler: async (args) => selectFocusArea(connection, snippetClient, args),
+        },
     ];
 }
 const selectSubjectSchema = {
@@ -832,6 +877,41 @@ const selectSkySchema = {
         selection_type: selectionTypeFragment,
     },
 };
+const selectFocusAreaSchema = {
+    type: 'object',
+    properties: {
+        in_focus_radius: {
+            type: 'number',
+            description: 'How much blur still counts as "in focus", in pixels. Higher pulls more of the soft transition zone into the selection; lower keeps only the crisply resolved plane. 4.07 is the Photoshop dialog default and a sane starting point. The useful band is narrow, and a radius well above the default selects the entire frame — so move in small steps and CHECK the returned area_percent and whole_canvas_selected: a selection covering essentially everything means the radius is too high and the result is worthless, even though the call reports success.',
+            default: 4.07,
+            minimum: 0.1,
+            maximum: 15,
+        },
+        soft_mask: {
+            type: 'boolean',
+            description: 'False (default) yields a hard-edged selection — every pixel fully in or fully out, which is what you want before ps_modify_selection feathering. True lets Photoshop feather the focus falloff itself, useful when the subject edge is genuinely gradual (hair, fur, motion).',
+            default: false,
+        },
+        selection_type: selectionTypeFragment,
+    },
+};
+async function selectFocusArea(connection, snippetClient, rawArgs) {
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: selectFocusAreaSchema,
+        snippet: 'selectFocusArea',
+        errorPrefix: 'Error running Focus Area selection',
+        timeoutMs: SELECT_FOCUS_AREA_TIMEOUT_MS,
+        params: (args) => ({
+            inFocusRadius: args.in_focus_radius ?? 4.07,
+            softMask: args.soft_mask ?? false,
+            selectionType: normalizeSelectionType(args.selection_type),
+        }),
+        successText: (_result, args) => `Focus Area selection (${normalizeSelectionType(args.selection_type)}) complete`,
+    });
+}
 async function selectSubject(connection, snippetClient, rawArgs) {
     return runSnippetTool({
         connection,
@@ -864,17 +944,6 @@ async function selectSky(connection, snippetClient, rawArgs) {
         successText: (_result, args) => `Select Sky (${normalizeSelectionType(args.selection_type)}) complete`,
     });
 }
-function unknownDiscriminator(kind, value, allowed) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `Error: unknown ${kind} "${String(value)}". Allowed: ${allowed.join(', ')}.`,
-            },
-        ],
-        isError: true,
-    };
-}
 async function select(connection, snippetClient, detClient, rawArgs) {
     const mode = rawArgs.mode;
     const { mode: _omit, ...rest } = rawArgs;
@@ -924,6 +993,10 @@ async function modifySelection(connection, snippetClient, rawArgs) {
             return modifySelectionEdge(connection, snippetClient, op, rest);
         case 'transform':
             return transformSelection(connection, snippetClient, rest);
+        case 'grow':
+            return growSelection(connection, snippetClient, 'grow', rest);
+        case 'similar':
+            return growSelection(connection, snippetClient, 'similar', rest);
         default:
             return unknownDiscriminator('modify_selection op', op, MODIFY_SELECTION_OPS);
     }

package/dist/tools/sky-tools.js

@@ -0,0 +1,126 @@
+import { runSnippetTool } from '../utils/tool-helpers.js';
+import { SKY_REPLACEMENT_TIMEOUT_MS } from '../utils/operation-timeouts.js';
+const PLACEHOLDER_SKY_ID = '00000000-0000-0000-0000-000000000000';
+const replaceSkyInputSchema = {
+    type: 'object',
+    properties: {
+        sky_file: {
+            type: 'string',
+            description: 'ABSOLUTE path to the image to use as the sky. Any image Photoshop can open works — it does not need to be a registered Photoshop sky preset. The built-in skies live as .jpg files under the Sky_Presets folder inside your Photoshop settings directory, and their paths can be passed here directly.',
+        },
+        sky_name: {
+            type: 'string',
+            description: 'Label recorded on the operation. Cosmetic — it does not select the sky, sky_file does.',
+            default: 'Custom Sky',
+        },
+        shift_edge: {
+            type: 'number',
+            description: 'Moves the sky/foreground boundary inward (negative) or outward (positive). Use it when the horizon leaves a halo or eats into the foreground.',
+            default: 0,
+            minimum: -100,
+            maximum: 100,
+        },
+        border_smoothness: {
+            type: 'number',
+            description: 'Softens the boundary between sky and foreground. 0 is a hard cut.',
+            default: 50,
+            minimum: 0,
+            maximum: 100,
+        },
+        brightness: {
+            type: 'number',
+            description: 'Brightness of the replaced sky itself.',
+            default: 0,
+            minimum: -100,
+            maximum: 100,
+        },
+        temperature: {
+            type: 'number',
+            description: 'Warms (positive) or cools (negative) the replaced sky.',
+            default: 0,
+            minimum: -100,
+            maximum: 100,
+        },
+        harmonization_opacity: {
+            type: 'number',
+            description: 'How strongly the foreground is colour-graded to match the new sky. This is what sells the composite — 0 leaves the foreground untouched and usually reads as pasted-on.',
+            default: 35,
+            minimum: 0,
+            maximum: 100,
+        },
+        foreground_lighting_opacity: {
+            type: 'number',
+            description: 'Strength of the relighting applied to the foreground so it appears lit by the new sky.',
+            default: 78,
+            minimum: 0,
+            maximum: 100,
+        },
+        edge_lighting_opacity: {
+            type: 'number',
+            description: 'Strength of the light wrap along the foreground edge where it meets the sky.',
+            default: 70,
+            minimum: 0,
+            maximum: 100,
+        },
+    },
+    required: ['sky_file'],
+};
+async function replaceSky(connection, snippetClient, rawArgs) {
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: replaceSkyInputSchema,
+        snippet: 'replaceSky',
+        errorPrefix: 'Error running Sky Replacement',
+        timeoutMs: SKY_REPLACEMENT_TIMEOUT_MS,
+        params: (args) => ({
+            skyPath: args.sky_file,
+            skyName: args.sky_name ?? 'Custom Sky',
+            skyId: PLACEHOLDER_SKY_ID,
+            shiftEdge: args.shift_edge ?? 0,
+            borderSmoothness: args.border_smoothness ?? 50,
+            brightness: args.brightness ?? 0,
+            temperature: args.temperature ?? 0,
+            harmonizationOpacity: args.harmonization_opacity ?? 35,
+            foregroundLightingOpacity: args.foreground_lighting_opacity ?? 78,
+            edgeLightingOpacity: args.edge_lighting_opacity ?? 70,
+        }),
+        successText: (_result, args) => `Sky replaced using ${String(args.sky_file)}`,
+    });
+}
+export function createSkyTools(connection, snippetClient) {
+    return [
+        {
+            tool: {
+                name: 'ps_replace_sky',
+                description: 'Run Photoshop\'s Sky Replacement (Adobe Sensei): detect the sky, composite a replacement, and relight/colour-grade the foreground to match. Non-destructive — everything lands in a "Sky Replacement Group" of editable layers above the original, so the result can be tuned or deleted afterwards. sky_file takes an ABSOLUTE path to ANY image on disk, not only Photoshop\'s built-in presets. Reach for harmonization_opacity and foreground_lighting_opacity when the composite reads as pasted-on; those two carry most of the believability. Fails cleanly when the image has no detectable sky (indoor or closed compositions).',
+                inputSchema: replaceSkyInputSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        replaced: { type: 'boolean' },
+                        strategy_used: { type: 'string' },
+                        group_name: {
+                            type: 'string',
+                            description: 'Name of the layer group Photoshop created.',
+                        },
+                        group_layers: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Layers inside the group, top to bottom — typically the sky layer, an edge-lighting group, a foreground-lighting layer and a foreground-colour curves layer.',
+                        },
+                        sky_file: { type: 'string' },
+                        sky_name: { type: 'string' },
+                        context: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Replace Sky (Sensei)',
+                    idempotentHint: false,
+                },
+            },
+            handler: async (args) => replaceSky(connection, snippetClient, args),
+        },
+    ];
+}

package/dist/tools/smart-object-tools.js

@@ -0,0 +1,163 @@
+import { validateArgs } from '../utils/validate.js';
+import { runSnippetTool, toolErrorResult } from '../utils/tool-helpers.js';
+import { LAYER_BLEND_MODES } from '../utils/blend-modes.js';
+const SMART_FILTER_OPS = ['list', 'set_visibility', 'set_blend', 'remove'];
+const smartFilterInputSchema = {
+    type: 'object',
+    properties: {
+        op: {
+            type: 'string',
+            enum: [...SMART_FILTER_OPS],
+            description: 'list: read every Smart Filter on the active layer (index, name, type, enabled, opacity, blend mode). Read-only — call it first to get the indices the other ops take. ' +
+                'set_visibility: turn one filter on or off without removing it (needs `index` + `enabled`). ' +
+                "set_blend: change one filter's `opacity` and/or `blend_mode` (needs `index` + at least one of them). " +
+                'remove: delete one filter from the stack (needs `index`). Removing a filter renumbers every index above it — re-run op=list before the next index-taking call.',
+        },
+        index: {
+            type: 'integer',
+            description: "1-based index of the filter to act on, as reported by op=list. 1 is the FIRST-APPLIED filter (bottom of the Smart Filters stack in the Layers panel). Required for every op except 'list'.",
+            minimum: 1,
+            maximum: 1000,
+        },
+        enabled: {
+            type: 'boolean',
+            description: 'set_visibility only: true shows the filter, false hides it. The filter stays in the stack either way and keeps all its settings.',
+        },
+        opacity: {
+            type: 'number',
+            description: 'set_blend only: filter opacity 0-100. Omit to leave the current opacity untouched.',
+            minimum: 0,
+            maximum: 100,
+        },
+        blend_mode: {
+            type: 'string',
+            enum: [...LAYER_BLEND_MODES],
+            description: 'set_blend only: how the filter result composites against the unfiltered layer. Same names as ps_set_layer. Omit to leave the current mode untouched.',
+        },
+    },
+    required: ['op'],
+};
+export async function runSmartFilterOp(connection, snippetClient, rawArgs) {
+    let args;
+    try {
+        args = validateArgs(smartFilterInputSchema, rawArgs);
+    }
+    catch (error) {
+        return toolErrorResult('Error in ps_filter', error);
+    }
+    const op = args.op;
+    if (op !== 'list' && args.index === undefined) {
+        return toolErrorResult('Error in ps_filter', new Error(`op=${op} needs an \`index\`. Call op=list first to see the filters and their indices.`));
+    }
+    switch (op) {
+        case 'list':
+            return runSnippetTool({
+                connection,
+                snippetClient,
+                rawArgs: args,
+                schema: smartFilterInputSchema,
+                snippet: 'listSmartFilters',
+                errorPrefix: 'Error listing Smart Filters',
+                successText: (result) => summarizeList(result),
+            });
+        case 'set_visibility': {
+            if (args.enabled === undefined) {
+                return toolErrorResult('Error in ps_filter', new Error('op=set_visibility needs `enabled` (true to show the filter, false to hide it).'));
+            }
+            return runSnippetTool({
+                connection,
+                snippetClient,
+                rawArgs: args,
+                schema: smartFilterInputSchema,
+                snippet: 'setSmartFilterVisibility',
+                errorPrefix: 'Error setting Smart Filter visibility',
+                params: (a) => ({ index: a.index, enabled: a.enabled }),
+                successText: (result) => {
+                    const r = result;
+                    return `${r.enabled ? 'Showed' : 'Hid'} Smart Filter ${String(r.index)} (${String(r.filter_name)}) on "${String(r.layer_name)}".`;
+                },
+            });
+        }
+        case 'set_blend': {
+            if (args.opacity === undefined && args.blend_mode === undefined) {
+                return toolErrorResult('Error in ps_filter', new Error('op=set_blend needs at least one of `opacity` or `blend_mode`.'));
+            }
+            return runSnippetTool({
+                connection,
+                snippetClient,
+                rawArgs: args,
+                schema: smartFilterInputSchema,
+                snippet: 'setSmartFilterBlend',
+                errorPrefix: 'Error setting Smart Filter blend',
+                params: (a) => {
+                    const p = { index: a.index };
+                    if (a.opacity !== undefined)
+                        p.opacity = a.opacity;
+                    if (a.blend_mode !== undefined)
+                        p.blendMode = a.blend_mode;
+                    return p;
+                },
+                successText: (result) => {
+                    const r = result;
+                    const opacity = Number(r.opacity);
+                    const opacityText = Number.isFinite(opacity) ? opacity.toFixed(1) : String(r.opacity);
+                    return `Smart Filter ${String(r.index)} (${String(r.filter_name)}) is now ${String(r.blend_mode)} at ${opacityText}% opacity on "${String(r.layer_name)}".`;
+                },
+            });
+        }
+        case 'remove':
+            return runSnippetTool({
+                connection,
+                snippetClient,
+                rawArgs: args,
+                schema: smartFilterInputSchema,
+                snippet: 'removeSmartFilter',
+                errorPrefix: 'Error removing Smart Filter',
+                params: (a) => ({ index: a.index }),
+                successText: (result) => {
+                    const r = result;
+                    return `Removed Smart Filter ${String(r.index)} (${String(r.removed_filter_name)}) from "${String(r.layer_name)}". ${String(r.remaining_count)} remaining. Indices renumbered — re-run op=list before the next index-taking call.`;
+                },
+            });
+        default:
+            return toolErrorResult('Error in ps_filter', new Error(`Unknown smart-filter op: ${String(op)}. Allowed: ${SMART_FILTER_OPS.join(', ')}.`));
+    }
+}
+function summarizeList(r) {
+    const layer = String(r.layer_name ?? '');
+    if (r.is_smart_object !== true) {
+        return `"${layer}" is not a Smart Object, so it has no Smart Filters. Convert it with ps_convert_to_smart_object to make filters re-editable.`;
+    }
+    const filters = Array.isArray(r.filters) ? r.filters : [];
+    if (filters.length === 0) {
+        return `"${layer}" is a Smart Object with no Smart Filters yet. Add one with ps_filter as_smart_filter=true.`;
+    }
+    const lines = filters.map((f) => {
+        const state = f.enabled === false ? ' [hidden]' : '';
+        const blend = f.blend_mode === 'NORMAL' && f.opacity === 100
+            ? ''
+            : ` — ${String(f.blend_mode)} @ ${String(f.opacity)}%`;
+        return `  ${String(f.index)}. ${String(f.name)} (${String(f.type)})${blend}${state}`;
+    });
+    return `"${layer}" has ${filters.length} Smart Filter${filters.length === 1 ? '' : 's'} (1 = first applied, bottom of the stack):\n${lines.join('\n')}`;
+}
+export async function getSmartObjectInfoHandler(connection, snippetClient) {
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs: {},
+        schema: { type: 'object', properties: {} },
+        snippet: 'getSmartObjectInfo',
+        errorPrefix: 'Error reading Smart Object info',
+        successText: (result) => {
+            const r = result;
+            const layer = String(r.layer_name ?? '');
+            if (r.is_smart_object !== true) {
+                return `"${layer}" is not a Smart Object (kind: ${String(r.layer_kind)}).`;
+            }
+            const storage = r.linked === true ? `linked to ${String(r.file_reference)}` : 'embedded';
+            const n = Number(r.smart_filter_count ?? 0);
+            return `"${layer}" is a ${storage} Smart Object with ${n} Smart Filter${n === 1 ? '' : 's'}.`;
+        },
+    });
+}

package/dist/tools/text-tools.js

@@ -1,6 +1,7 @@
 import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
-import { toolErrorResult, runSnippetTool } from '../utils/tool-helpers.js';
+import { toolErrorResult, runSnippetTool, unknownDiscriminator } from '../utils/tool-helpers.js';
+import { createTextLayer, createTextLayerSchema } from './layer-tools.js';
 const setTextFontSchema = {
     type: 'object',
     properties: {
@@ -69,77 +70,97 @@ const updateTextContentSchema = {
     },
     required: ['text'],
 };
-const SET_TEXT_PROPERTIES = ['font', 'color', 'alignment', 'content'];
-const SET_TEXT_INPUT_SCHEMA = {
+const TEXT_OPS = ['create', 'set_content', 'set_font', 'set_color', 'set_alignment'];
+export const TEXT_OP_SCHEMAS = {
+    create: createTextLayerSchema,
+    set_content: updateTextContentSchema,
+    set_font: setTextFontSchema,
+    set_color: setTextColorSchema,
+    set_alignment: setTextAlignmentSchema,
+};
+const TEXT_INPUT_SCHEMA = {
     type: 'object',
     properties: {
-        property: {
+        op: {
             type: 'string',
-            enum: [...SET_TEXT_PROPERTIES],
-            description: 'Which text attribute to set on the active text layer: ' +
-                'font(font_name, optional font_size); color(red, green, blue); ' +
-                'alignment(alignment); content(text).',
+            enum: [...TEXT_OPS],
+            description: 'create: new text layer with `text` at `x`/`y` (default 100,100) and `font_size` (default 24). ' +
+                "set_content: replace the active text layer's content with `text`. " +
+                "set_font: set the active text layer's font to `font_name` (optionally `font_size`). " +
+                "set_color: set the active text layer's color to `red`/`green`/`blue`. " +
+                "set_alignment: set the active text layer's `alignment`.",
         },
-        ...setTextFontSchema.properties,
+        ...createTextLayerSchema.properties,
         ...setTextColorSchema.properties,
         ...setTextAlignmentSchema.properties,
-        ...updateTextContentSchema.properties,
+        font_name: setTextFontSchema.properties.font_name,
+        text: {
+            type: 'string',
+            description: 'create: initial text content. set_content: new text content, replacing the existing text.',
+        },
+        font_size: {
+            type: 'number',
+            description: "Font size in points, up to 1296 — Photoshop's own ceiling for the Character panel. create: initial size (default 24). set_font: new size (optional — omit to leave the current size unchanged).",
+            default: 24,
+            minimum: 1,
+            maximum: 1296,
+        },
     },
-    required: ['property'],
+    required: ['op'],
 };
 export function createTextTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'ps_set_text',
-                description: 'Set an attribute of the currently active text layer — font (family or PostScript name, optionally size), color (RGB), alignment, or text content — selected via `property`. Idempotent. Throws if the active layer is not a text layer. Font names accept either the PostScript name ("ArialMT") or family name ("Arial", resolved to its Regular/first variant); throws clearly if no installed font matches.',
-                inputSchema: SET_TEXT_INPUT_SCHEMA,
+                name: 'ps_text',
+                description: 'Text layer — create it or style it, chosen with `op`. create: a new text layer with `text` at `x`/`y` and `font_size`. set_content/set_font/set_color/set_alignment act on the currently active text layer (throws if it isn\'t one). Font names accept either the PostScript name ("ArialMT") or family name ("Arial", resolved to its Regular/first variant); throws clearly if no installed font matches. The set_* ops are idempotent.',
+                inputSchema: TEXT_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',
                     properties: {
-                        requested: { type: 'string' },
-                        font: { type: 'string' },
-                        size: { type: 'number' },
+                        created: { type: 'boolean', description: 'op=create: true on success.' },
+                        layerName: { type: 'string', description: 'op=create: the new layer name.' },
+                        position: { type: 'object', description: 'op=create: {x, y}.' },
+                        fontSize: { type: 'number', description: 'op=create: the size applied.' },
+                        requested: { type: 'string', description: 'op=set_font: the font requested.' },
+                        font: { type: 'string', description: 'op=set_font: the font actually matched.' },
+                        size: { type: 'number', description: 'op=set_font: the size applied, if given.' },
                         matched_by: {
                             type: 'string',
                             enum: ['postScriptName', 'family+regular', 'family', 'name'],
+                            description: 'op=set_font: how `font_name` was resolved.',
                         },
-                        color: { type: 'string' },
-                        alignment: { type: 'string' },
-                        text: { type: 'string' },
+                        color: { type: 'string', description: 'op=set_color: the RGB() string applied.' },
+                        alignment: { type: 'string', description: 'op=set_alignment: the alignment applied.' },
+                        text: { type: 'string', description: 'op=create/set_content: the text content.' },
+                        context: { type: 'object' },
                     },
                 },
                 annotations: {
-                    title: 'Set Text',
-                    idempotentHint: true,
+                    title: 'Text',
+                    idempotentHint: false,
                 },
             },
-            handler: async (args) => setText(connection, snippetClient, args),
+            handler: async (args) => textDispatch(connection, snippetClient, args),
         },
     ];
 }
-async function setText(connection, snippetClient, rawArgs) {
-    const property = rawArgs.property;
-    const { property: _omit, ...rest } = rawArgs;
-    switch (property) {
-        case 'font':
+async function textDispatch(connection, snippetClient, rawArgs) {
+    const op = rawArgs.op;
+    const { op: _omit, ...rest } = rawArgs;
+    switch (op) {
+        case 'create':
+            return createTextLayer(connection, snippetClient, rest);
+        case 'set_content':
+            return updateTextContent(connection, snippetClient, rest);
+        case 'set_font':
             return setTextFont(connection, snippetClient, rest);
-        case 'color':
+        case 'set_color':
             return setTextColor(connection, snippetClient, rest);
-        case 'alignment':
+        case 'set_alignment':
             return setTextAlignment(connection, snippetClient, rest);
-        case 'content':
-            return updateTextContent(connection, snippetClient, rest);
         default:
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Error: unknown text property "${String(property)}". Allowed: ${SET_TEXT_PROPERTIES.join(', ')}.`,
-                    },
-                ],
-                isError: true,
-            };
+            return unknownDiscriminator('text op', op, TEXT_OPS);
     }
 }
 async function setTextFont(connection, snippetClient, rawArgs) {