@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/tools/task/index.js

@@ -0,0 +1,150 @@
+import { TASK_TOOL_SCHEMA } from './schema.js';
+const DEFAULT_SESSION_ID = 'local';
+function summarizeRef(ref) {
+    if (!ref)
+        return null;
+    return {
+        sessionId: ref.sessionId,
+        taskId: ref.taskId,
+        title: ref.title,
+        label: ref.label,
+        status: ref.status,
+        createdAt: ref.createdAt,
+        updatedAt: ref.updatedAt,
+    };
+}
+export function createTaskTool(registry) {
+    return {
+        definition: {
+            name: 'task',
+            description: 'Manage durable cross-session task refs, dependencies, cancellations, and handoffs.',
+            parameters: TASK_TOOL_SCHEMA,
+            sideEffects: ['workflow', 'state'],
+            concurrency: 'serial',
+        },
+        async execute(args) {
+            if (!args || typeof args !== 'object' || typeof args.mode !== 'string') {
+                return { success: false, error: 'Invalid args: mode is required.' };
+            }
+            const input = args;
+            const sessionId = input.sessionId?.trim() || DEFAULT_SESSION_ID;
+            const view = input.view ?? 'summary';
+            if (input.mode === 'create') {
+                if (!input.taskId || !input.title) {
+                    return { success: false, error: 'create requires taskId and title.' };
+                }
+                const now = Date.now();
+                const result = registry.linkTask({
+                    sessionId,
+                    taskId: input.taskId,
+                    title: input.title,
+                    status: input.status ?? 'queued',
+                    createdAt: now,
+                    updatedAt: now,
+                    ...(input.label ? { label: input.label } : {}),
+                });
+                if (!result.ok)
+                    return { success: false, error: result.error ?? 'task link failed' };
+                return { success: true, output: JSON.stringify(registry.getRef(sessionId, input.taskId)) };
+            }
+            if (input.mode === 'list') {
+                const refs = registry.getRefsBySession(sessionId);
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        sessionId,
+                        view,
+                        count: refs.length,
+                        refs: view === 'full' ? refs : refs.map((ref) => summarizeRef(ref)),
+                    }),
+                };
+            }
+            if (input.mode === 'show') {
+                if (!input.taskId)
+                    return { success: false, error: 'show requires taskId.' };
+                const ref = registry.getRef(sessionId, input.taskId);
+                if (!ref)
+                    return { success: false, error: `Unknown task ref: ${sessionId}:${input.taskId}` };
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        ref: view === 'full' ? ref : summarizeRef(ref),
+                        dependencies: registry.getDependencies(sessionId, input.taskId),
+                        dependents: registry.getDependents(sessionId, input.taskId),
+                    }),
+                };
+            }
+            if (input.mode === 'status') {
+                if (!input.taskId || !input.status)
+                    return { success: false, error: 'status requires taskId and status.' };
+                const changed = registry.propagateStatus(sessionId, input.taskId, input.status);
+                if (!changed)
+                    return { success: false, error: `Task ref not updated: ${sessionId}:${input.taskId}` };
+                return { success: true, output: JSON.stringify(registry.getRef(sessionId, input.taskId)) };
+            }
+            if (input.mode === 'depend') {
+                if (!input.taskId || !input.dependsOnTaskId) {
+                    return { success: false, error: 'depend requires taskId and dependsOnTaskId.' };
+                }
+                const ref = registry.getRef(sessionId, input.taskId);
+                if (!ref)
+                    return { success: false, error: `Unknown task ref: ${sessionId}:${input.taskId}` };
+                const result = registry.linkTask(ref, {
+                    sessionId: input.dependsOnSessionId?.trim() || sessionId,
+                    taskId: input.dependsOnTaskId,
+                }, input.reason);
+                if (!result.ok)
+                    return { success: false, error: result.error ?? 'dependency link failed' };
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        ref,
+                        dependencies: registry.getDependencies(sessionId, input.taskId),
+                    }),
+                };
+            }
+            if (input.mode === 'cancel') {
+                const result = registry.cancel({
+                    sessionId,
+                    ...(input.taskId ? { taskId: input.taskId } : {}),
+                    scope: input.scope ?? 'task',
+                    requestedAt: Date.now(),
+                    ...(input.reason ? { reason: input.reason } : {}),
+                });
+                if (!result.ok)
+                    return { success: false, error: result.error ?? 'cancel failed' };
+                return { success: true, output: JSON.stringify(result) };
+            }
+            if (input.mode === 'handoff') {
+                if (!input.taskId || !input.toSessionId) {
+                    return { success: false, error: 'handoff requires taskId and toSessionId.' };
+                }
+                const result = registry.initiateHandoff({ sessionId, taskId: input.taskId }, sessionId, input.toSessionId, input.reason);
+                if (!result.ok)
+                    return { success: false, error: result.error ?? 'handoff failed' };
+                return { success: true, output: JSON.stringify({ handoffId: result.handoffId }) };
+            }
+            if (input.mode === 'handoffs') {
+                const handoffs = registry.getHandoffs();
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        view,
+                        count: handoffs.length,
+                        handoffs: view === 'full'
+                            ? handoffs
+                            : handoffs.map((handoff) => ({
+                                handoffId: handoff.handoffId,
+                                fromSessionId: handoff.fromSessionId,
+                                toSessionId: handoff.toSessionId,
+                                taskRef: handoff.taskRef,
+                                acknowledged: handoff.acknowledged,
+                                initiatedAt: handoff.initiatedAt,
+                            })),
+                    }),
+                };
+            }
+            return { success: false, error: `Unknown mode: ${input.mode}` };
+        },
+    };
+}

package/dist/platform/tools/task/schema.d.ts

@@ -0,0 +1,62 @@
+export declare const TASK_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["create", "list", "show", "status", "depend", "cancel", "handoff", "handoffs"];
+        };
+        readonly view: {
+            readonly type: "string";
+            readonly enum: readonly ["summary", "full"];
+        };
+        readonly sessionId: {
+            readonly type: "string";
+        };
+        readonly taskId: {
+            readonly type: "string";
+        };
+        readonly title: {
+            readonly type: "string";
+        };
+        readonly label: {
+            readonly type: "string";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["queued", "running", "blocked", "completed", "failed", "cancelled"];
+        };
+        readonly dependsOnSessionId: {
+            readonly type: "string";
+        };
+        readonly dependsOnTaskId: {
+            readonly type: "string";
+        };
+        readonly reason: {
+            readonly type: "string";
+        };
+        readonly toSessionId: {
+            readonly type: "string";
+        };
+        readonly scope: {
+            readonly type: "string";
+            readonly enum: readonly ["task", "subtree", "session"];
+        };
+    };
+    readonly required: readonly ["mode"];
+    readonly additionalProperties: false;
+};
+export type TaskToolInput = {
+    mode: 'create' | 'list' | 'show' | 'status' | 'depend' | 'cancel' | 'handoff' | 'handoffs';
+    view?: 'summary' | 'full';
+    sessionId?: string;
+    taskId?: string;
+    title?: string;
+    label?: string;
+    status?: 'queued' | 'running' | 'blocked' | 'completed' | 'failed' | 'cancelled';
+    dependsOnSessionId?: string;
+    dependsOnTaskId?: string;
+    reason?: string;
+    toSessionId?: string;
+    scope?: 'task' | 'subtree' | 'session';
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/platform/tools/task/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/task/schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BnB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;IAC3F,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;IACjF,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;CACxC,CAAC"}

package/dist/platform/tools/task/schema.js

@@ -0,0 +1,28 @@
+export const TASK_TOOL_SCHEMA = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['create', 'list', 'show', 'status', 'depend', 'cancel', 'handoff', 'handoffs'],
+        },
+        view: { type: 'string', enum: ['summary', 'full'] },
+        sessionId: { type: 'string' },
+        taskId: { type: 'string' },
+        title: { type: 'string' },
+        label: { type: 'string' },
+        status: {
+            type: 'string',
+            enum: ['queued', 'running', 'blocked', 'completed', 'failed', 'cancelled'],
+        },
+        dependsOnSessionId: { type: 'string' },
+        dependsOnTaskId: { type: 'string' },
+        reason: { type: 'string' },
+        toSessionId: { type: 'string' },
+        scope: {
+            type: 'string',
+            enum: ['task', 'subtree', 'session'],
+        },
+    },
+    required: ['mode'],
+    additionalProperties: false,
+};

package/dist/platform/tools/team/index.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from '../../types/tools.js';
+export declare const teamTool: Tool;
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/tools/team/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/team/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AA4DjD,eAAO,MAAM,QAAQ,EAAE,IA4HtB,CAAC"}

package/dist/platform/tools/team/index.js

@@ -0,0 +1,149 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { TEAM_TOOL_SCHEMA } from './schema.js';
+function summarizeTeam(team) {
+    return {
+        id: team.id,
+        name: team.name,
+        summary: team.summary,
+        memberCount: team.members.length,
+        lanes: Array.from(new Set(team.members.flatMap((member) => member.lanes))).sort(),
+        createdAt: team.createdAt,
+        updatedAt: team.updatedAt,
+    };
+}
+function teamsPath(storageRoot) {
+    return join(storageRoot, '.goodvibes', 'sdk', 'teams.json');
+}
+function loadTeams(storageRoot) {
+    const path = teamsPath(storageRoot);
+    if (!existsSync(path))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        return parsed?.version === 1 && Array.isArray(parsed.teams) ? [...parsed.teams] : [];
+    }
+    catch {
+        return [];
+    }
+}
+function saveTeams(storageRoot, teams) {
+    const path = teamsPath(storageRoot);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ version: 1, teams }, null, 2) + '\n', 'utf-8');
+}
+export const teamTool = {
+    definition: {
+        name: 'team',
+        description: 'Manage durable team definitions, roles, and communication lanes.',
+        parameters: TEAM_TOOL_SCHEMA,
+        sideEffects: ['workflow', 'state'],
+        concurrency: 'serial',
+    },
+    async execute(args) {
+        if (!args || typeof args !== 'object' || typeof args.mode !== 'string') {
+            return { success: false, error: 'Invalid args: mode is required.' };
+        }
+        const input = args;
+        if (!input.storageRoot || input.storageRoot.trim().length === 0) {
+            return { success: false, error: 'team requires storageRoot.' };
+        }
+        const teams = loadTeams(input.storageRoot);
+        const view = input.view ?? 'summary';
+        if (input.mode === 'create') {
+            if (!input.teamId || !input.name || !input.summary) {
+                return { success: false, error: 'create requires teamId, name, and summary.' };
+            }
+            if (teams.some((team) => team.id === input.teamId)) {
+                return { success: false, error: `Team already exists: ${input.teamId}` };
+            }
+            const now = Date.now();
+            const team = {
+                id: input.teamId,
+                name: input.name,
+                summary: input.summary,
+                members: [],
+                createdAt: now,
+                updatedAt: now,
+            };
+            saveTeams(input.storageRoot, [...teams, team]);
+            return { success: true, output: JSON.stringify(team) };
+        }
+        if (input.mode === 'list') {
+            return {
+                success: true,
+                output: JSON.stringify({
+                    view,
+                    count: teams.length,
+                    teams: view === 'full' ? teams : teams.map(summarizeTeam),
+                }),
+            };
+        }
+        const index = teams.findIndex((team) => team.id === input.teamId);
+        if (index < 0) {
+            return { success: false, error: `Unknown team: ${input.teamId ?? '(missing)'}` };
+        }
+        const current = teams[index];
+        if (input.mode === 'show') {
+            return {
+                success: true,
+                output: JSON.stringify(view === 'full' ? current : {
+                    ...summarizeTeam(current),
+                    members: current.members.map((member) => ({
+                        id: member.id,
+                        role: member.role,
+                        lanes: member.lanes,
+                    })),
+                }),
+            };
+        }
+        if (input.mode === 'delete') {
+            saveTeams(input.storageRoot, teams.filter((team) => team.id !== input.teamId));
+            return { success: true, output: JSON.stringify({ removed: input.teamId }) };
+        }
+        if (input.mode === 'add-member') {
+            if (!input.memberId || !input.role) {
+                return { success: false, error: 'add-member requires memberId and role.' };
+            }
+            const next = {
+                ...current,
+                members: [
+                    ...current.members.filter((member) => member.id !== input.memberId),
+                    { id: input.memberId, role: input.role, lanes: input.lanes ?? [] },
+                ],
+                updatedAt: Date.now(),
+            };
+            teams[index] = next;
+            saveTeams(input.storageRoot, teams);
+            return { success: true, output: JSON.stringify(next) };
+        }
+        if (input.mode === 'remove-member') {
+            if (!input.memberId)
+                return { success: false, error: 'remove-member requires memberId.' };
+            const next = {
+                ...current,
+                members: current.members.filter((member) => member.id !== input.memberId),
+                updatedAt: Date.now(),
+            };
+            teams[index] = next;
+            saveTeams(input.storageRoot, teams);
+            return { success: true, output: JSON.stringify(next) };
+        }
+        if (input.mode === 'set-lanes') {
+            if (!input.memberId)
+                return { success: false, error: 'set-lanes requires memberId.' };
+            const members = current.members.map((member) => (member.id === input.memberId
+                ? { ...member, lanes: input.lanes ?? [] }
+                : member));
+            const next = {
+                ...current,
+                members,
+                updatedAt: Date.now(),
+            };
+            teams[index] = next;
+            saveTeams(input.storageRoot, teams);
+            return { success: true, output: JSON.stringify(next) };
+        }
+        return { success: false, error: `Unknown mode: ${input.mode}` };
+    },
+};

package/dist/platform/tools/team/schema.d.ts

@@ -0,0 +1,47 @@
+export declare const TEAM_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["create", "list", "show", "add-member", "remove-member", "set-lanes", "delete"];
+        };
+        readonly view: {
+            readonly type: "string";
+            readonly enum: readonly ["summary", "full"];
+        };
+        readonly teamId: {
+            readonly type: "string";
+        };
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly summary: {
+            readonly type: "string";
+        };
+        readonly memberId: {
+            readonly type: "string";
+        };
+        readonly role: {
+            readonly type: "string";
+        };
+        readonly lanes: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly required: readonly ["mode"];
+    readonly additionalProperties: false;
+};
+export type TeamToolInput = {
+    mode: 'create' | 'list' | 'show' | 'add-member' | 'remove-member' | 'set-lanes' | 'delete';
+    view?: 'summary' | 'full';
+    teamId?: string;
+    name?: string;
+    summary?: string;
+    memberId?: string;
+    role?: string;
+    lanes?: string[];
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/platform/tools/team/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/team/schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBnB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,GAAG,eAAe,GAAG,WAAW,GAAG,QAAQ,CAAC;IAC3F,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC"}

package/dist/platform/tools/team/schema.js

@@ -0,0 +1,21 @@
+export const TEAM_TOOL_SCHEMA = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['create', 'list', 'show', 'add-member', 'remove-member', 'set-lanes', 'delete'],
+        },
+        view: { type: 'string', enum: ['summary', 'full'] },
+        teamId: { type: 'string' },
+        name: { type: 'string' },
+        summary: { type: 'string' },
+        memberId: { type: 'string' },
+        role: { type: 'string' },
+        lanes: {
+            type: 'array',
+            items: { type: 'string' },
+        },
+    },
+    required: ['mode'],
+    additionalProperties: false,
+};

package/dist/platform/tools/web-search/schema.d.ts

@@ -0,0 +1,59 @@
+export declare const WEB_SEARCH_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly query: {
+            readonly type: "string";
+            readonly description: "Web search query to execute.";
+        };
+        readonly providerId: {
+            readonly type: "string";
+            readonly description: "Optional provider id. Defaults to the built-in default provider.";
+        };
+        readonly maxResults: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 25;
+            readonly description: "Maximum number of ranked results to return. Default 10.";
+        };
+        readonly verbosity: {
+            readonly type: "string";
+            readonly enum: readonly ["urls_only", "titles", "snippets", "evidence", "full"];
+            readonly description: string;
+        };
+        readonly region: {
+            readonly type: "string";
+            readonly description: "Provider-specific region code such as us-en for DuckDuckGo.";
+        };
+        readonly safeSearch: {
+            readonly type: "string";
+            readonly enum: readonly ["strict", "moderate", "off"];
+            readonly description: "Safe-search posture. Default provider behavior is moderate.";
+        };
+        readonly timeRange: {
+            readonly type: "string";
+            readonly enum: readonly ["any", "day", "week", "month", "year"];
+            readonly description: "Optional recency filter.";
+        };
+        readonly includeInstantAnswer: {
+            readonly type: "boolean";
+            readonly description: "When supported, include provider instant-answer enrichment.";
+        };
+        readonly includeEvidence: {
+            readonly type: "boolean";
+            readonly description: "Attach fetched evidence from the top ranked pages.";
+        };
+        readonly evidenceTopN: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 10;
+            readonly description: "How many top results to fetch for evidence when evidence is enabled.";
+        };
+        readonly evidenceExtract: {
+            readonly type: "string";
+            readonly enum: readonly ["raw", "text", "json", "markdown", "readable", "code_blocks", "links", "metadata", "structured", "tables", "pdf", "summary"];
+            readonly description: "Fetch extraction mode to use for evidence fetches.";
+        };
+    };
+    readonly required: readonly ["query"];
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/platform/tools/web-search/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/web-search/schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DzB,CAAC"}

package/dist/platform/tools/web-search/schema.js

@@ -0,0 +1,59 @@
+export const WEB_SEARCH_TOOL_SCHEMA = {
+    type: 'object',
+    properties: {
+        query: {
+            type: 'string',
+            description: 'Web search query to execute.',
+        },
+        providerId: {
+            type: 'string',
+            description: 'Optional provider id. Defaults to the built-in default provider.',
+        },
+        maxResults: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 25,
+            description: 'Maximum number of ranked results to return. Default 10.',
+        },
+        verbosity: {
+            type: 'string',
+            enum: ['urls_only', 'titles', 'snippets', 'evidence', 'full'],
+            description: 'urls_only returns ranked URLs, titles adds titles, snippets adds descriptions,'
+                + ' evidence fetches bounded excerpts from the top results, and full fetches fuller readable excerpts.',
+        },
+        region: {
+            type: 'string',
+            description: 'Provider-specific region code such as us-en for DuckDuckGo.',
+        },
+        safeSearch: {
+            type: 'string',
+            enum: ['strict', 'moderate', 'off'],
+            description: 'Safe-search posture. Default provider behavior is moderate.',
+        },
+        timeRange: {
+            type: 'string',
+            enum: ['any', 'day', 'week', 'month', 'year'],
+            description: 'Optional recency filter.',
+        },
+        includeInstantAnswer: {
+            type: 'boolean',
+            description: 'When supported, include provider instant-answer enrichment.',
+        },
+        includeEvidence: {
+            type: 'boolean',
+            description: 'Attach fetched evidence from the top ranked pages.',
+        },
+        evidenceTopN: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 10,
+            description: 'How many top results to fetch for evidence when evidence is enabled.',
+        },
+        evidenceExtract: {
+            type: 'string',
+            enum: ['raw', 'text', 'json', 'markdown', 'readable', 'code_blocks', 'links', 'metadata', 'structured', 'tables', 'pdf', 'summary'],
+            description: 'Fetch extraction mode to use for evidence fetches.',
+        },
+    },
+    required: ['query'],
+};